chore: Add check for prehandle-handle consistency (#21285)

Signed-off-by: Michael Heinrichs <[email protected]>
Signed-off-by: Kelly Greco <[email protected]>
Co-authored-by: Kelly Greco <[email protected]>
Co-authored-by: Kelly Greco <[email protected]>

Author: netopyr

platform-sdk/consensus-otter-docker-app/src/testFixtures/java/org/hiero/consensus/otter/docker/app/platform/ConsensusNodeManager.java

@@ -36,6 +36,7 @@
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Random;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executor;
 import org.apache.logging.log4j.LogManager;
@@ -135,7 +136,7 @@ public ConsensusNodeManager(
         final MerkleNodeState state = initialState.get().getState();
 
         final RosterHistory rosterHistory = RosterUtils.createRosterHistory(state);
-        executionCallback = new OtterExecutionLayer(metrics);
+        executionCallback = new OtterExecutionLayer(new Random(), metrics);
         final PlatformBuilder builder = PlatformBuilder.create(
                         OtterApp.APP_NAME,
                         OtterApp.SWIRLD_NAME,

platform-sdk/consensus-otter-tests/docs/turtle-environment.md

@@ -368,7 +368,7 @@ void testDeterministicBehavior(@NonNull final TestEnvironment env) throws Interr
             network.newConsensusResults().results().getFirst().lastRoundNum();
 
     // This assertion will always pass with seed=42
-    assertThat(lastRound).isEqualTo(46L);
+    assertThat(lastRound).isEqualTo(47L);
 }
 ```
 

platform-sdk/consensus-otter-tests/src/testFixtures/java/org/hiero/otter/fixtures/TransactionFactory.java

@@ -22,44 +22,51 @@ private TransactionFactory() {}
     /**
      * Creates a new empty transaction.
      *
+     * @param nonce the nonce for the empty transaction
      * @return an empty transaction
      */
-    public static OtterTransaction createEmptyTransaction(final int nonce) {
+    public static OtterTransaction createEmptyTransaction(final long nonce) {
         final EmptyTransaction emptyTransaction = EmptyTransaction.newBuilder().build();
         return OtterTransaction.newBuilder()
+                .setNonce(nonce)
                 .setEmptyTransaction(emptyTransaction)
                 .build();
     }
 
     /**
      * Creates a freeze transaction with the specified freeze time.
      *
+     * @param nonce the nonce for the transaction
      * @param freezeTime the freeze time for the transaction
      * @return a FreezeTransaction with the provided freeze time
      */
-    public static OtterTransaction createFreezeTransaction(@NonNull final Instant freezeTime) {
+    public static OtterTransaction createFreezeTransaction(final long nonce, @NonNull final Instant freezeTime) {
         final Timestamp timestamp = CommonPbjConverters.fromPbj(CommonUtils.toPbjTimestamp(freezeTime));
         final OtterFreezeTransaction freezeTransaction =
                 OtterFreezeTransaction.newBuilder().setFreezeTime(timestamp).build();
         return OtterTransaction.newBuilder()
+                .setNonce(nonce)
                 .setFreezeTransaction(freezeTransaction)
                 .build();
     }
 
     /**
      * Creates a transaction with the specified inner StateSignatureTransaction.
      *
+     * @param nonce the nonce for the transaction
      * @param innerTxn the StateSignatureTransaction
      * @return a TurtleTransaction with the specified inner transaction
      */
-    public static OtterTransaction createStateSignatureTransaction(@NonNull final StateSignatureTransaction innerTxn) {
+    public static OtterTransaction createStateSignatureTransaction(
+            final long nonce, @NonNull final StateSignatureTransaction innerTxn) {
         final com.hedera.hapi.platform.event.legacy.StateSignatureTransaction legacyInnerTxn =
                 com.hedera.hapi.platform.event.legacy.StateSignatureTransaction.newBuilder()
                         .setRound(innerTxn.round())
                         .setSignature(ByteString.copyFrom(innerTxn.signature().toByteArray()))
                         .setHash(ByteString.copyFrom(innerTxn.hash().toByteArray()))
                         .build();
         return OtterTransaction.newBuilder()
+                .setNonce(nonce)
                 .setStateSignatureTransaction(legacyInnerTxn)
                 .build();
     }

platform-sdk/consensus-otter-tests/src/testFixtures/java/org/hiero/otter/fixtures/app/OtterApp.java

@@ -11,29 +11,34 @@
 import com.swirlds.platform.system.Platform;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
+import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.hiero.consensus.model.event.ConsensusEvent;
 import org.hiero.consensus.model.event.Event;
 import org.hiero.consensus.model.hashgraph.Round;
 import org.hiero.consensus.model.roster.AddressBook;
 import org.hiero.consensus.model.transaction.ConsensusTransaction;
 import org.hiero.consensus.model.transaction.ScopedSystemTransaction;
+import org.hiero.consensus.model.transaction.Transaction;
 import org.hiero.otter.fixtures.app.services.consistency.ConsistencyService;
 import org.hiero.otter.fixtures.app.services.platform.PlatformStateService;
 import org.hiero.otter.fixtures.app.services.roster.RosterService;
 import org.hiero.otter.fixtures.app.state.OtterStateInitializer;
 
 /**
- * The main entry point for the Otter application. This class is instantiated by the platform when the
- * application is started. It creates the services that make up the application and routes events and rounds
- * to those services.
+ * The main entry point for the Otter application. This class is instantiated by the platform when the application is
+ * started. It creates the services that make up the application and routes events and rounds to those services.
  */
 @SuppressWarnings("removal")
 public class OtterApp implements ConsensusStateEventHandler<OtterAppState> {
 
+    private static final Logger log = LogManager.getLogger();
+
     public static final String APP_NAME = "org.hiero.otter.fixtures.app.OtterApp";
     public static final String SWIRLD_NAME = "123";
 
@@ -91,7 +96,24 @@ public void onPreHandle(
             @NonNull final Event event,
             @NonNull final OtterAppState state,
             @NonNull final Consumer<ScopedSystemTransaction<StateSignatureTransaction>> callback) {
-        consistencyService.recordPreHandleTransactions(event);
+        for (final OtterService service : allServices) {
+            service.preHandleEvent(event);
+        }
+        for (final Iterator<Transaction> transactionIterator = event.transactionIterator();
+                transactionIterator.hasNext(); ) {
+            try {
+                final OtterTransaction transaction = OtterTransaction.parseFrom(
+                        transactionIterator.next().getApplicationTransaction().toInputStream());
+                for (final OtterService service : allServices) {
+                    service.preHandleTransaction(event, transaction, callback);
+                }
+            } catch (final IOException ex) {
+                log.error(
+                        "Unable to parse OtterTransaction created by node {}",
+                        event.getCreatorId().id(),
+                        ex);
+            }
+        }
     }
 
     /**
@@ -103,20 +125,30 @@ public void onHandleConsensusRound(
             @NonNull final OtterAppState state,
             @NonNull final Consumer<ScopedSystemTransaction<StateSignatureTransaction>> callback) {
         for (final OtterService service : allServices) {
-            service.onRound(state.getWritableStates(service.name()), round);
+            service.handleRound(state.getWritableStates(service.name()), round);
         }
 
         for (final ConsensusEvent consensusEvent : round) {
             for (final OtterService service : allServices) {
-                service.onEvent(state.getWritableStates(service.name()), consensusEvent);
+                service.handleEvent(state.getWritableStates(service.name()), consensusEvent);
             }
             for (final Iterator<ConsensusTransaction> transactionIterator =
                             consensusEvent.consensusTransactionIterator();
                     transactionIterator.hasNext(); ) {
-                final ConsensusTransaction transaction = transactionIterator.next();
-                for (final OtterService service : allServices) {
-                    service.onTransaction(
-                            state.getWritableStates(service.name()), consensusEvent, transaction, callback);
+                try {
+                    final OtterTransaction transaction = OtterTransaction.parseFrom(transactionIterator
+                            .next()
+                            .getApplicationTransaction()
+                            .toInputStream());
+                    for (final OtterService service : allServices) {
+                        service.handleTransaction(
+                                state.getWritableStates(service.name()), consensusEvent, transaction, callback);
+                    }
+                } catch (final IOException ex) {
+                    log.error(
+                            "Unable to parse OtterTransaction created by node {}",
+                            consensusEvent.getCreatorId().id(),
+                            ex);
                 }
             }
         }

platform-sdk/consensus-otter-tests/src/testFixtures/java/org/hiero/otter/fixtures/app/OtterExecutionLayer.java

@@ -1,13 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 package org.hiero.otter.fixtures.app;
 
+import static java.util.Objects.requireNonNull;
+
 import com.hedera.hapi.platform.event.StateSignatureTransaction;
 import com.hedera.pbj.runtime.io.buffer.Bytes;
 import com.swirlds.metrics.api.Metrics;
 import com.swirlds.platform.builder.ExecutionLayer;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.time.Duration;
 import java.util.List;
+import java.util.Random;
 import org.hiero.consensus.model.status.PlatformStatus;
 import org.hiero.consensus.transaction.TransactionPoolNexus;
 import org.hiero.otter.fixtures.TransactionFactory;
@@ -22,14 +25,27 @@ public class OtterExecutionLayer implements ExecutionLayer {
     /** the transaction pool, stores transactions that should be sumbitted to the network */
     private final TransactionPoolNexus transactionPool;
 
-    public OtterExecutionLayer(@NonNull final Metrics metrics) {
+    private final Random random;
+
+    /**
+     * Constructs a new OtterExecutionLayer.
+     *
+     * @param random the source of randomness for populating signature transaction nonce values.
+     * @param metrics the metrics system to use
+     */
+    public OtterExecutionLayer(@NonNull final Random random, @NonNull final Metrics metrics) {
+        this.random = requireNonNull(random);
         transactionPool = new TransactionPoolNexus(getTransactionLimits(), TX_QUEUE_SIZE, metrics);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void submitStateSignature(@NonNull final StateSignatureTransaction transaction) {
-        transactionPool.submitPriorityTransaction(Bytes.wrap(
-                TransactionFactory.createStateSignatureTransaction(transaction).toByteArray()));
+        transactionPool.submitPriorityTransaction(
+                Bytes.wrap(TransactionFactory.createStateSignatureTransaction(random.nextLong(), transaction)
+                        .toByteArray()));
     }
 
     /**
@@ -41,22 +57,34 @@ public boolean submitApplicationTransaction(@NonNull final byte[] transaction) {
         return transactionPool.submitApplicationTransaction(Bytes.wrap(transaction));
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @NonNull
     @Override
     public List<Bytes> getTransactionsForEvent() {
         return transactionPool.getTransactionsForEvent();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public boolean hasBufferedSignatureTransactions() {
         return transactionPool.hasBufferedSignatureTransactions();
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void newPlatformStatus(@NonNull final PlatformStatus platformStatus) {
         transactionPool.updatePlatformStatus(platformStatus);
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public void reportUnhealthyDuration(@NonNull final Duration duration) {
         transactionPool.reportUnhealthyDuration(duration);

platform-sdk/consensus-otter-tests/src/testFixtures/java/org/hiero/otter/fixtures/app/OtterService.java

@@ -35,25 +35,26 @@ public interface OtterService {
     Schema genesisSchema(@NonNull SemanticVersion version);
 
     /**
-     * Called when a new round of consensus has been received. The service should only do actions
-     * for the whole round in this method. For actions on individual events, use {@link #onEvent(WritableStates, Event)}.
-     * For actions on individual transactions, use {@link #onTransaction(WritableStates, Event, Transaction, Consumer)}.
+     * Called when a new round of consensus has been received. The service should only do actions for the whole round in
+     * this method. For actions on individual events, use {@link #handleEvent(WritableStates, Event)}. For actions on
+     * individual transactions, use {@link #handleTransaction(WritableStates, Event, Transaction, Consumer)}.
      *
      * @param writableStates the {@link WritableStates} to use to modify state
-     * @param round
+     * @param round the round to handle
      */
-    default void onRound(@NonNull final WritableStates writableStates, @NonNull final Round round) {
+    default void handleRound(@NonNull final WritableStates writableStates, @NonNull final Round round) {
         // Default implementation does nothing
     }
 
     /**
      * Called when a new event has been received. The service should only do actions for the whole event in this method.
-     * For actions on individual transactions, use {@link #onTransaction(WritableStates, Event, Transaction, Consumer)}.
+     * For actions on individual transactions, use
+     * {@link #handleTransaction(WritableStates, Event, OtterTransaction, Consumer)}.
      *
      * @param writableStates the {@link WritableStates} to use to modify state
      * @param event the event to handle
      */
-    default void onEvent(@NonNull final WritableStates writableStates, @NonNull final Event event) {
+    default void handleEvent(@NonNull final WritableStates writableStates, @NonNull final Event event) {
         // Default implementation does nothing
     }
 
@@ -65,10 +66,35 @@ default void onEvent(@NonNull final WritableStates writableStates, @NonNull fina
      * @param transaction the transaction to handle
      * @param callback a callback to pass any system transactions to be handled by the platform
      */
-    default void onTransaction(
+    default void handleTransaction(
             @NonNull final WritableStates writableStates,
             @NonNull final Event event,
-            @NonNull final Transaction transaction,
+            @NonNull final OtterTransaction transaction,
+            @NonNull final Consumer<ScopedSystemTransaction<StateSignatureTransaction>> callback) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Called when an event is being pre-handled. This is called before any transactions in the event are pre-handled.
+     * The service should only do actions for the whole event in this method. For actions on individual transactions,
+     * use {@link #preHandleTransaction(Event, OtterTransaction, Consumer)}.
+     *
+     * @param event the event being pre-handled
+     */
+    default void preHandleEvent(@NonNull final Event event) {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Called when a transaction is being pre-handled.
+     *
+     * @param event the event that contains the transaction
+     * @param transaction the transaction being pre-handled
+     * @param callback a callback to pass any system transactions to be handled by the platform
+     */
+    default void preHandleTransaction(
+            @NonNull final Event event,
+            @NonNull final OtterTransaction transaction,
             @NonNull final Consumer<ScopedSystemTransaction<StateSignatureTransaction>> callback) {
         // Default implementation does nothing
     }