@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/src/public/{public_processor.ts → public_processor/public_processor.ts}

@@ -1,7 +1,20 @@
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type FailedTx,
-  MerkleTreeId,
-  type MerkleTreeWriteOperations,
+  GlobalVariables,
   NestedProcessReturnValues,
   type ProcessedTx,
   Tx,
@@ -9,23 +22,7 @@ import {
   type TxValidator,
   makeProcessedTxFromPrivateOnlyTx,
   makeProcessedTxFromTxWithPublicCalls,
-} from '@aztec/circuit-types';
-import {
-  type AztecAddress,
-  type ContractDataSource,
-  Fr,
-  Gas,
-  type GlobalVariables,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
-  PublicDataWrite,
-} from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { type DateProvider, Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+} from '@aztec/stdlib/tx';
 import {
   Attributes,
   type TelemetryClient,
@@ -34,11 +31,11 @@ import {
   getTelemetryClient,
   trackSpan,
 } from '@aztec/telemetry-client';
+import { ForkCheckpoint } from '@aztec/world-state/native';
 
-import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
-import { WorldStateDB } from './public_db_sources.js';
+import { WorldStateDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
-import { PublicTxSimulator } from './public_tx_simulator.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -54,13 +51,13 @@ export class PublicProcessorFactory {
    * Creates a new instance of a PublicProcessor.
    * @param historicalHeader - The header of a block previous to the one in which the tx is included.
    * @param globalVariables - The global variables for the block being processed.
-   * @param enforceFeePayment - Allows disabling balance checks for fee estimations.
+   * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
    * @returns A new instance of a PublicProcessor.
    */
   public create(
     merkleTree: MerkleTreeWriteOperations,
     globalVariables: GlobalVariables,
-    enforceFeePayment: boolean,
+    skipFeeEnforcement: boolean,
   ): PublicProcessor {
     const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
     const publicTxSimulator = this.createPublicTxSimulator(
@@ -68,7 +65,7 @@ export class PublicProcessorFactory {
       worldStateDB,
       globalVariables,
       /*doMerkleOperations=*/ true,
-      enforceFeePayment,
+      skipFeeEnforcement,
       this.telemetryClient,
     );
 
@@ -87,7 +84,7 @@ export class PublicProcessorFactory {
     worldStateDB: WorldStateDB,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
-    enforceFeePayment: boolean,
+    skipFeeEnforcement: boolean,
     telemetryClient: TelemetryClient,
   ) {
     return new PublicTxSimulator(
@@ -95,7 +92,7 @@ export class PublicProcessorFactory {
       worldStateDB,
       globalVariables,
       doMerkleOperations,
-      enforceFeePayment,
+      skipFeeEnforcement,
       telemetryClient,
     );
   }
@@ -222,6 +219,11 @@ export class PublicProcessor implements Traceable {
         }
       }
 
+      // We checkpoint the transaction here, then within the try/catch we
+      // 1. Revert the checkpoint if the tx fails or needs to be discarded for any reason
+      // 2. Commit the transaction in the finally block. Note that by using the ForkCheckpoint lifecycle only the first commit/revert takes effect
+      const checkpoint = await ForkCheckpoint.new(this.worldStateDB);
+
       try {
         const [processedTx, returnValues] = await this.processTx(tx, deadline);
 
@@ -234,6 +236,8 @@ export class PublicProcessor implements Traceable {
             totalSizeInBytes,
             maxBlockSize,
           });
+          // Need to revert the checkpoint here and don't go any further
+          await checkpoint.revert();
           continue;
         }
 
@@ -249,14 +253,24 @@ export class PublicProcessor implements Traceable {
             const reason = result.reason.join(', ');
             this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
             failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
+            // Need to revert the checkpoint here and don't go any further
+            await checkpoint.revert();
             continue;
           } else {
-            this.log.trace(`Tx ${(await tx.getTxHash()).toString()} is valid post processing.`);
+            this.log.trace(`Tx ${txHash.toString()} is valid post processing.`);
           }
         }
 
-        // Otherwise, commit tx state for the next tx to be processed
-        await this.commitTxState(processedTx);
+        if (!tx.hasPublicCalls()) {
+          // If there are no public calls, perform all tree insertions for side effects from private
+          // When there are public calls, the PublicTxSimulator & AVM handle tree insertions.
+          await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
+          // Add any contracts registered/deployed in this private-only tx to the block-level cache
+          // (add to tx-level cache and then commit to block-level cache)
+          await this.worldStateDB.addNewContracts(tx);
+          this.worldStateDB.commitContractsForTx();
+        }
+
         nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
         result.push(processedTx);
         returns = returns.concat(returnValues);
@@ -265,15 +279,22 @@ export class PublicProcessor implements Traceable {
         totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
         totalSizeInBytes += txSize;
       } catch (err: any) {
+        // Roll back state to start of TX before proceeding to next TX
+        await checkpoint.revert();
         if (err?.name === 'PublicProcessorTimeoutError') {
           this.log.warn(`Stopping tx processing due to timeout.`);
           break;
         }
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
+        this.log.warn(`Failed to process tx ${txHash.toString()}: ${errorMessage} ${err?.stack}`);
 
         failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
         returns.push(new NestedProcessReturnValues([]));
+      } finally {
+        // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was reverted
+        await checkpoint.commit();
+        // The tx-level contracts cache should not live on to the next tx
+        this.worldStateDB.clearContractsForTx();
       }
     }
 
@@ -281,7 +302,7 @@ export class PublicProcessor implements Traceable {
     const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
     this.metrics.recordAllTxs(totalPublicGas, rate);
 
-    this.log.info(`Processed ${result.length} successful txs and ${failed.length} txs in ${duration}s`, {
+    this.log.info(`Processed ${result.length} successful txs and ${failed.length} failed txs in ${duration}s`, {
       duration,
       rate,
       totalPublicGas,
@@ -309,7 +330,7 @@ export class PublicProcessor implements Traceable {
         publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
         nullifierCount: processedTx.txEffect.nullifiers.length,
         noteHashCount: processedTx.txEffect.noteHashes.length,
-        contractClassLogCount: processedTx.txEffect.contractClassLogs.getTotalLogCount(),
+        contractClassLogCount: processedTx.txEffect.contractClassLogs.length,
         publicLogCount: processedTx.txEffect.publicLogs.length,
         privateLogCount: processedTx.txEffect.privateLogs.length,
         l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
@@ -320,10 +341,11 @@ export class PublicProcessor implements Traceable {
     return [processedTx, returnValues ?? []];
   }
 
-  private async commitTxState(processedTx: ProcessedTx, txValidator?: TxValidator<ProcessedTx>): Promise<void> {
-    // Commit the state updates from this transaction
-    // TODO(palla/txs): It seems like this doesn't do anything...?
-    await this.worldStateDB.commit();
+  private async doTreeInsertionsForPrivateOnlyTx(
+    processedTx: ProcessedTx,
+    txValidator?: TxValidator<ProcessedTx>,
+  ): Promise<void> {
+    const treeInsertionStart = process.hrtime.bigint();
 
     // Update the state so that the next tx in the loop has the correct .startState
     // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
@@ -331,7 +353,6 @@ export class PublicProcessor implements Traceable {
     // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
     // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
     // The below is taken from buildBaseRollupHints:
-    const treeInsertionStart = process.hrtime.bigint();
     await this.db.appendLeaves(
       MerkleTreeId.NOTE_HASH_TREE,
       padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
@@ -352,6 +373,7 @@ export class PublicProcessor implements Traceable {
       }
     }
 
+    // The only public data write should be for fee payment
     await this.db.sequentialInsert(
       MerkleTreeId.PUBLIC_DATA_TREE,
       processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
@@ -397,12 +419,7 @@ export class PublicProcessor implements Traceable {
    * This is used in private only txs, since for txs with public calls
    * the avm handles the fee payment itself.
    */
-  private async getFeePaymentPublicDataWrite(txFee: Fr, feePayer: AztecAddress): Promise<PublicDataWrite | undefined> {
-    if (feePayer.isZero()) {
-      this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
-      return;
-    }
-
+  private async getFeePaymentPublicDataWrite(txFee: Fr, feePayer: AztecAddress): Promise<PublicDataWrite> {
     const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
     const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
     const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
@@ -439,11 +456,15 @@ export class PublicProcessor implements Traceable {
       this.globalVariables,
     );
 
+    const siloedContractClassLogs = await tx.filterContractClassLogs(
+      tx.data.getNonEmptyContractClassLogsHashes(),
+      true,
+    );
+
     this.metrics.recordClassRegistration(
-      ...tx.contractClassLogs
-        .unrollLogs()
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
-        .map(log => ContractClassRegisteredEvent.fromLog(log.data)),
+      ...siloedContractClassLogs
+        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
+        .map(log => ContractClassRegisteredEvent.fromLog(log)),
     );
     return [processedTx, undefined];
   }
@@ -463,18 +484,22 @@ export class PublicProcessor implements Traceable {
     }
 
     processedPhases.forEach(phase => {
-      if (phase.revertReason) {
+      if (phase.reverted) {
         this.metrics.recordRevertedPhase(phase.phase);
       } else {
         this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
       }
     });
 
+    const siloedContractClassLogs = await tx.filterContractClassLogs(
+      tx.data.getNonEmptyContractClassLogsHashes(),
+      true,
+    );
+
     this.metrics.recordClassRegistration(
-      ...tx.contractClassLogs
-        .unrollLogs()
-        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
-        .map(log => ContractClassRegisteredEvent.fromLog(log.data)),
+      ...siloedContractClassLogs
+        .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
+        .map(log => ContractClassRegisteredEvent.fromLog(log)),
     );
 
     const phaseCount = processedPhases.length;

package/src/public/{public_processor_metrics.ts → public_processor/public_processor_metrics.ts}

@@ -1,6 +1,6 @@
-import { type TxExecutionPhase } from '@aztec/circuit-types';
-import { type Gas } from '@aztec/circuits.js';
-import { type ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { TxExecutionPhase } from '@aztec/stdlib/tx';
 import {
   Attributes,
   type Gauge,

package/src/public/{public_tx_context.ts → public_tx_simulator/public_tx_context.ts}

@@ -1,50 +1,54 @@
 import {
-  type AvmProvingRequest,
-  MerkleTreeId,
-  type MerkleTreeReadOperations,
-  ProvingRequestType,
-  type PublicExecutionRequest,
-  type SimulationError,
-  type Tx,
-  TxExecutionPhase,
-  type TxHash,
-} from '@aztec/circuit-types';
-import {
-  AvmCircuitInputs,
-  type AvmCircuitPublicInputs,
-  type AztecAddress,
-  Fr,
-  Gas,
-  type GasSettings,
-  type GlobalVariables,
   MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  NULLIFIER_SUBTREE_HEIGHT,
+} from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { assertLength } from '@aztec/foundation/serialize';
+import {
+  AvmCircuitInputs,
+  type AvmCircuitPublicInputs,
+  type AvmProvingRequest,
+  PublicDataWrite,
+  RevertCode,
+} from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { computeTransactionFee } from '@aztec/stdlib/fees';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
   type PrivateToPublicAccumulatedData,
   PublicCallRequest,
-  PublicDataWrite,
-  RevertCode,
-  type StateReference,
-  TreeSnapshots,
-  computeTransactionFee,
   countAccumulatedItems,
   mergeAccumulatedData,
-} from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { assertLength } from '@aztec/foundation/serialize';
+} from '@aztec/stdlib/kernel';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import {
+  type GlobalVariables,
+  type PublicExecutionRequest,
+  type StateReference,
+  TreeSnapshots,
+  type Tx,
+  TxExecutionPhase,
+  type TxHash,
+} from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
 import { AvmPersistableStateManager } from '../avm/index.js';
-import { type WorldStateDB } from './public_db_sources.js';
-import { SideEffectArrayLengths, SideEffectTrace } from './side_effect_trace.js';
-import { getCallRequestsByPhase, getExecutionRequestsByPhase } from './utils.js';
+import type { WorldStateDB } from '../public_db_sources.js';
+import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
+import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
 
 /**
  * The transaction-level context for public execution.
@@ -111,12 +115,7 @@ export class PublicTxContext {
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = await AvmPersistableStateManager.create(
-      worldStateDB,
-      trace,
-      doMerkleOperations,
-      firstNullifier,
-    );
+    const txStateManager = AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations, firstNullifier);
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
     const gasUsedByPrivate = tx.data.gasUsed;
@@ -149,9 +148,9 @@ export class PublicTxContext {
    * All phases have been processed.
    * Actual transaction fee and actual total consumed gas can now be queried.
    */
-  halt() {
+  async halt() {
     if (this.state.isForked()) {
-      this.state.mergeForkedState();
+      await this.state.mergeForkedState();
     }
     this.halted = true;
   }
@@ -325,37 +324,7 @@ export class PublicTxContext {
    */
   private async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
-    const ephemeralTrees = this.state.getActiveStateManager().merkleTrees;
-
-    const noteHashTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE);
-    const nullifierTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE);
-    const publicDataTree = await ephemeralTrees.getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE);
-
-    // Pad the note hash and nullifier trees
-    const paddedNoteHashTreeSize =
-      this.startStateReference.partial.noteHashTree.nextAvailableLeafIndex + MAX_NOTE_HASHES_PER_TX;
-    if (noteHashTree.nextAvailableLeafIndex > paddedNoteHashTreeSize) {
-      throw new Error(
-        `Inserted too many leaves in note hash tree: ${noteHashTree.nextAvailableLeafIndex} > ${paddedNoteHashTreeSize}`,
-      );
-    }
-    noteHashTree.nextAvailableLeafIndex = paddedNoteHashTreeSize;
-
-    const paddedNullifierTreeSize =
-      this.startStateReference.partial.nullifierTree.nextAvailableLeafIndex + MAX_NULLIFIERS_PER_TX;
-    if (nullifierTree.nextAvailableLeafIndex > paddedNullifierTreeSize) {
-      throw new Error(
-        `Inserted too many leaves in nullifier tree: ${nullifierTree.nextAvailableLeafIndex} > ${paddedNullifierTreeSize}`,
-      );
-    }
-    nullifierTree.nextAvailableLeafIndex = paddedNullifierTreeSize;
-
-    const endTreeSnapshots = new TreeSnapshots(
-      endStateReference.l1ToL2MessageTree,
-      noteHashTree,
-      nullifierTree,
-      publicDataTree,
-    );
+    const stateManager = this.state.getActiveStateManager();
 
     const startTreeSnapshots = new TreeSnapshots(
       this.startStateReference.l1ToL2MessageTree,
@@ -364,6 +333,14 @@ export class PublicTxContext {
       this.startStateReference.partial.publicDataTree,
     );
 
+    // Will be patched/padded at the end of this fn
+    const endTreeSnapshots = new TreeSnapshots(
+      endStateReference.l1ToL2MessageTree,
+      endStateReference.partial.noteHashTree,
+      endStateReference.partial.nullifierTree,
+      endStateReference.partial.publicDataTree,
+    );
+
     const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(
       this.globalVariables,
       startTreeSnapshots,
@@ -427,6 +404,24 @@ export class PublicTxContext {
       PublicDataWrite.empty(),
       MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
     );
+    const numNoteHashesToPad =
+      MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
+    await stateManager.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
+    const numNullifiersToPad =
+      MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
+    await stateManager.db.batchInsert(
+      MerkleTreeId.NULLIFIER_TREE,
+      padArrayEnd([], Fr.ZERO, numNullifiersToPad).map(nullifier => nullifier.toBuffer()),
+      NULLIFIER_SUBTREE_HEIGHT,
+    );
+
+    const paddedState = await stateManager.db.getStateReference();
+    avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(
+      paddedState.l1ToL2MessageTree,
+      paddedState.partial.noteHashTree,
+      paddedState.partial.nullifierTree,
+      paddedState.partial.publicDataTree,
+    );
 
     return avmCircuitPublicInputs;
   }
@@ -467,10 +462,10 @@ class PhaseStateManager {
     this.log = createLogger(`simulator:public_phase_state_manager`);
   }
 
-  fork() {
+  async fork() {
     assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
     this.log.debug(`Forking phase state manager`);
-    this.currentlyActiveStateManager = this.txStateManager.fork();
+    this.currentlyActiveStateManager = await this.txStateManager.fork();
   }
 
   getActiveStateManager() {
@@ -481,18 +476,18 @@ class PhaseStateManager {
     return !!this.currentlyActiveStateManager;
   }
 
-  mergeForkedState() {
+  async mergeForkedState() {
     assert(this.currentlyActiveStateManager, 'No forked state to merge');
     this.log.debug(`Merging in forked state`);
-    this.txStateManager.merge(this.currentlyActiveStateManager!);
+    await this.txStateManager.merge(this.currentlyActiveStateManager!);
     // Drop the forked state manager now that it is merged
     this.currentlyActiveStateManager = undefined;
   }
 
-  discardForkedState() {
+  async discardForkedState() {
     this.log.debug(`Discarding forked state`);
     assert(this.currentlyActiveStateManager, 'No forked state to discard');
-    this.txStateManager.reject(this.currentlyActiveStateManager!);
+    await this.txStateManager.reject(this.currentlyActiveStateManager!);
     // Drop the forked state manager. We don't want it!
     this.currentlyActiveStateManager = undefined;
   }