@aztec/txe 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/src/rpc_translator.ts

@@ -210,6 +210,26 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_txe_sendL1ToL2Message(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_sendL1ToL2Message',
+      inputs,
+      handler: ([content, secretHash, sender, recipient]) =>
+        this.handlerAsTxe().sendL1ToL2Message(content, secretHash, sender, recipient),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_txe_setTaggingSecretStrategies(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_txe_setTaggingSecretStrategies',
+      inputs,
+      handler: ([unconstrainedStrategy, constrainedStrategy]) =>
+        this.handlerAsTxe().setTaggingSecretStrategies(unconstrainedStrategy, constrainedStrategy),
+    });
+  }
+
   // PXE oracles
 
   // eslint-disable-next-line camelcase
@@ -271,20 +291,8 @@ export class RPCTranslator {
     return callTxeHandler({
       oracle: 'aztec_txe_getPrivateEvents',
       inputs,
-      handler: async ([selector, contractAddress, scope]) => {
-        // TODO(F-335): Avoid doing the following 2 calls here.
-        {
-          await this.handlerAsTxe().syncContractNonOracleMethod(
-            contractAddress,
-            scope,
-            this.stateHandler.getCurrentJob(),
-          );
-          // We cycle job to commit the stores after the contract sync.
-          await this.stateHandler.cycleJob();
-        }
-
-        return this.handlerAsTxe().getPrivateEvents(selector, contractAddress, scope);
-      },
+      handler: ([selector, contractAddress, scope]) =>
+        this.stateHandler.getPrivateEvents(selector, contractAddress, scope),
     });
   }
 
@@ -451,7 +459,7 @@ export class RPCTranslator {
     return callTxeHandler({
       oracle: 'aztec_utl_getKeyValidationRequest',
       inputs,
-      handler: ([pkMHash]) => this.handlerAsUtility().getKeyValidationRequest(pkMHash),
+      handler: ([pkMHash, keyIndex]) => this.handlerAsUtility().getKeyValidationRequest(pkMHash, keyIndex),
     });
   }
 
@@ -480,6 +488,16 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_getL1ToL2MembershipWitnessV2(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getL1ToL2MembershipWitnessV2',
+      inputs,
+      handler: ([messageHash, nullifier]) =>
+        this.handlerAsUtility().getL1ToL2MembershipWitnessV2(messageHash, nullifier),
+    });
+  }
+
   // eslint-disable-next-line camelcase
   aztec_utl_getAuthWitness(...inputs: ForeignCallArgs) {
     return callTxeHandler({
@@ -554,6 +572,16 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_areBlockHashesInArchive(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_areBlockHashesInArchive',
+      inputs,
+      handler: ([anchorBlockHash, blockHashes]) =>
+        this.handlerAsUtility().areBlockHashesInArchive(anchorBlockHash, blockHashes),
+    });
+  }
+
   // eslint-disable-next-line camelcase
   aztec_utl_getLowNullifierMembershipWitness(...inputs: ForeignCallArgs) {
     return callTxeHandler({
@@ -565,11 +593,11 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getPendingTaggedLogs(...inputs: ForeignCallArgs) {
+  aztec_utl_getPendingTaggedLogsV2(...inputs: ForeignCallArgs) {
     return callTxeHandler({
-      oracle: 'aztec_utl_getPendingTaggedLogs',
+      oracle: 'aztec_utl_getPendingTaggedLogsV2',
       inputs,
-      handler: ([scope, providedSecrets]) => this.handlerAsUtility().getPendingTaggedLogs(scope, providedSecrets),
+      handler: ([scope, providedSecrets]) => this.handlerAsUtility().getPendingTaggedLogsV2(scope, providedSecrets),
     });
   }
 
@@ -588,20 +616,20 @@ export class RPCTranslator {
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getLogsByTag(...inputs: ForeignCallArgs) {
+  aztec_utl_getLogsByTagV2(...inputs: ForeignCallArgs) {
     return callTxeHandler({
-      oracle: 'aztec_utl_getLogsByTag',
+      oracle: 'aztec_utl_getLogsByTagV2',
       inputs,
-      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getLogsByTag(requestArrayBaseSlot),
+      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getLogsByTagV2(requestArrayBaseSlot),
     });
   }
 
   // eslint-disable-next-line camelcase
-  aztec_utl_getMessageContextsByTxHash(...inputs: ForeignCallArgs) {
+  aztec_utl_getResolvedTxs(...inputs: ForeignCallArgs) {
     return callTxeHandler({
-      oracle: 'aztec_utl_getMessageContextsByTxHash',
+      oracle: 'aztec_utl_getResolvedTxs',
       inputs,
-      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getMessageContextsByTxHash(requestArrayBaseSlot),
+      handler: ([requestArrayBaseSlot]) => this.handlerAsUtility().getResolvedTxs(requestArrayBaseSlot),
     });
   }
 
@@ -707,6 +735,69 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_pushTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_pushTransient',
+      inputs,
+      handler: ([slot, elements]) => this.handlerAsUtility().pushTransient(slot, elements),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_popTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_popTransient',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().popTransient(slot),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_getTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTransient',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().getTransient(slot, index),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_setTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_setTransient',
+      inputs,
+      handler: ([slot, index, elements]) => this.handlerAsUtility().setTransient(slot, index, elements),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_getTransientLen(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getTransientLen',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().getTransientLen(slot),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_removeTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_removeTransient',
+      inputs,
+      handler: ([slot, index]) => this.handlerAsUtility().removeTransient(slot, index),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_clearTransient(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_clearTransient',
+      inputs,
+      handler: ([slot]) => this.handlerAsUtility().clearTransient(slot),
+    });
+  }
+
   // TODO: I forgot to add a corresponding function here, when I introduced an oracle method to txe_oracle.ts.
   // The compiler didn't throw an error, so it took me a while to learn of the existence of this file, and that I need
   // to implement this function here. Isn't there a way to programmatically identify that this is missing, given the
@@ -755,6 +846,54 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_utl_recordFact(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_recordFact',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId, factTypeId, payload, originBlock]) =>
+        this.handlerAsUtility().recordFact(
+          contractAddress,
+          scope,
+          factCollectionTypeId,
+          factCollectionId,
+          factTypeId,
+          payload,
+          originBlock,
+        ),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_deleteFactCollection(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_deleteFactCollection',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId]) =>
+        this.handlerAsUtility().deleteFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_getFactCollection(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getFactCollection',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId, factCollectionId]) =>
+        this.handlerAsUtility().getFactCollection(contractAddress, scope, factCollectionTypeId, factCollectionId),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_utl_getFactCollectionsByType(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_utl_getFactCollectionsByType',
+      inputs,
+      handler: ([contractAddress, scope, factCollectionTypeId]) =>
+        this.handlerAsUtility().getFactCollectionsByType(contractAddress, scope, factCollectionTypeId),
+    });
+  }
+
   // AVM opcodes
 
   // eslint-disable-next-line camelcase
@@ -958,13 +1097,12 @@ export class RPCTranslator {
     });
   }
 
-  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
   // eslint-disable-next-line camelcase
   aztec_txe_privateCallNewFlow(...inputs: ForeignCallArgs) {
     return callTxeHandler({
       oracle: 'aztec_txe_privateCallNewFlow',
       inputs,
-      handler: async ([
+      handler: ([
         from,
         targetContractAddress,
         functionSelector,
@@ -974,103 +1112,44 @@ export class RPCTranslator {
         additionalScopes,
         authorizedUtilityCallTargets,
         gasSettings,
-      ]) => {
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
-          const { returnValues, offchainEffects } = await this.handlerAsTxe().privateCallNewFlow(
-            from?.value,
-            targetContractAddress,
-            functionSelector,
-            args,
-            argsHash,
-            isStaticCall,
-            additionalScopes,
-            this.stateHandler.getCurrentJob(),
-            authorizedUtilityCallTargets,
-            gasSettings,
-          );
-
-          // Private execution collects offchain effects inside PXE's PrivateExecutionOracle rather than
-          // round-tripping them through `aztec_utl_emitOffchainEffect`, so the session buffer is empty
-          // at this point. Drain the effects from the execution tree into the session buffer so the
-          // next `env.offchain_messages()` call in the test sees them.
-          for (const data of offchainEffects) {
-            this.stateHandler.recordOffchainEffect(data);
-          }
-
-          // TODO(F-335): Avoid doing the following call here.
-          await this.stateHandler.cycleJob();
-
-          if (isStaticCall) {
-            // Static calls revert their checkpoint and mine no block, so there is no tx hash to tag
-            // offchain effects with. Querying `getLastTxEffects()` here would return an unrelated
-            // predecessor tx.
-            return { result: returnValues };
-          }
-          const { txHash } = await this.handlerAsTxe().getLastTxEffects();
-          return { result: returnValues, txHash: txHash.hash };
-        });
-
-        return returnValues;
-      },
+      ]) =>
+        this.stateHandler.executePrivateCall(
+          from,
+          targetContractAddress,
+          functionSelector,
+          args,
+          argsHash,
+          isStaticCall,
+          additionalScopes,
+          authorizedUtilityCallTargets,
+          gasSettings,
+        ),
     });
   }
 
-  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
   // eslint-disable-next-line camelcase
   aztec_txe_executeUtilityFunction(...inputs: ForeignCallArgs) {
     return callTxeHandler({
       oracle: 'aztec_txe_executeUtilityFunction',
       inputs,
-      handler: async ([targetContractAddress, functionSelector, args, authorizedUtilityCallTargets]) => {
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
-          const returnValues = await this.handlerAsTxe().executeUtilityFunction(
-            targetContractAddress,
-            functionSelector,
-            args,
-            this.stateHandler.getCurrentJob(),
-            authorizedUtilityCallTargets,
-          );
-
-          // TODO(F-335): Avoid doing the following call here.
-          await this.stateHandler.cycleJob();
-
-          return { result: returnValues };
-        });
-
-        return returnValues;
-      },
+      handler: ([from, targetContractAddress, functionSelector, args, authorizedUtilityCallTargets]) =>
+        this.stateHandler.executeUtilityFunction(
+          from,
+          targetContractAddress,
+          functionSelector,
+          args,
+          authorizedUtilityCallTargets,
+        ),
     });
   }
 
-  // TODO(F-674): Move orchestration logic into the handler so the transport layer is pure serialize->delegate->deserialize.
   // eslint-disable-next-line camelcase
   aztec_txe_publicCallNewFlow(...inputs: ForeignCallArgs) {
     return callTxeHandler({
       oracle: 'aztec_txe_publicCallNewFlow',
       inputs,
-      handler: async ([from, address, calldata, isStaticCall, gasSettings]) => {
-        const returnValues = await this.stateHandler.withTopLevelCallTracking(async () => {
-          const returnValues = await this.handlerAsTxe().publicCallNewFlow(
-            from?.value,
-            address,
-            calldata,
-            isStaticCall,
-            gasSettings,
-          );
-
-          // TODO(F-335): Avoid doing the following call here.
-          await this.stateHandler.cycleJob();
-
-          if (isStaticCall) {
-            // See equivalent branch in `aztec_txe_privateCallNewFlow`.
-            return { result: returnValues };
-          }
-          const { txHash } = await this.handlerAsTxe().getLastTxEffects();
-          return { result: returnValues, txHash: txHash.hash };
-        });
-
-        return returnValues;
-      },
+      handler: ([from, address, calldata, isStaticCall, gasSettings]) =>
+        this.stateHandler.executePublicCall(from, address, calldata, isStaticCall, gasSettings),
     });
   }
 
@@ -1083,6 +1162,25 @@ export class RPCTranslator {
     });
   }
 
+  // eslint-disable-next-line camelcase
+  aztec_prv_resolveTaggingStrategy(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_resolveTaggingStrategy',
+      inputs,
+      handler: ([sender, recipient, deliveryMode]) =>
+        this.handlerAsPrivate().resolveTaggingStrategy(sender, recipient, deliveryMode),
+    });
+  }
+
+  // eslint-disable-next-line camelcase
+  aztec_prv_resolveCustomRequest(...inputs: ForeignCallArgs) {
+    return callTxeHandler({
+      oracle: 'aztec_prv_resolveCustomRequest',
+      inputs,
+      handler: ([kind, payload]) => this.handlerAsPrivate().resolveCustomRequest(kind, payload),
+    });
+  }
+
   // eslint-disable-next-line camelcase
   aztec_prv_getAppTaggingSecret(...inputs: ForeignCallArgs) {
     return callTxeHandler({

package/src/state_machine/archiver.ts

@@ -92,7 +92,6 @@ export class TXEArchiver extends ArchiverDataSourceBase {
       proven: tipId,
       finalized: tipId,
       checkpointed: tipId,
-      proposedCheckpoint: tipId,
     };
   }
 

package/src/state_machine/dummy_p2p_client.ts

@@ -9,6 +9,7 @@ import type {
   P2PConfig,
   P2PDuplicateAttestationCallback,
   P2PDuplicateProposalCallback,
+  P2POversizedProposalCallback,
   P2PSyncState,
   PeerId,
   ReqRespSubProtocol,
@@ -121,6 +122,10 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getPendingTxCount"');
   }
 
+  public hasEligiblePendingTxs(_minCount: number): Promise<boolean> {
+    throw new Error('DummyP2P does not implement "hasEligiblePendingTxs"');
+  }
+
   public start(): Promise<void> {
     throw new Error('DummyP2P does not implement "start"');
   }
@@ -171,6 +176,10 @@ export class DummyP2P implements P2P {
     return Promise.resolve({ blockProposals: [], checkpointProposals: [] });
   }
 
+  public hasCheckpointProposalForSlot(_slot: SlotNumber): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
   public getL2BlockHash(_number: number): Promise<string | undefined> {
     throw new Error('DummyP2P does not implement "getL2BlockHash"');
   }
@@ -233,6 +242,10 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "registerDuplicateProposalCallback"');
   }
 
+  public registerOversizedProposalCallback(_callback: P2POversizedProposalCallback): void {
+    throw new Error('DummyP2P does not implement "registerOversizedProposalCallback"');
+  }
+
   public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {
     throw new Error('DummyP2P does not implement "registerDuplicateAttestationCallback"');
   }

package/src/state_machine/global_variable_builder.ts

@@ -1,16 +1,11 @@
 import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
-import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { FEE_ORACLE_LAG, GasFees } from '@aztec/stdlib/gas';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import {
-  type CheckpointGlobalVariables,
-  type FeeProvider,
-  type GlobalVariableBuilder,
-  GlobalVariables,
-} from '@aztec/stdlib/tx';
+import type { CheckpointGlobalVariables, FeeProvider, GlobalVariableBuilder } from '@aztec/stdlib/tx';
 
 /** Simple FeeProvider for TXE that returns zero fees. */
 export class TXEFeeProvider implements FeeProvider {
@@ -24,15 +19,6 @@ export class TXEFeeProvider implements FeeProvider {
 }
 
 export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
-  public buildGlobalVariables(
-    _blockNumber: BlockNumber,
-    _coinbase: EthAddress,
-    _feeRecipient: AztecAddress,
-    _slotNumber?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    return Promise.resolve(makeGlobalVariables());
-  }
-
   public buildCheckpointGlobalVariables(
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,

package/src/state_machine/index.ts

@@ -3,8 +3,14 @@ import { TestCircuitVerifier } from '@aztec/bb-prover/test';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnchorBlockStore, type ContractStore, ContractSyncService, type NoteStore } from '@aztec/pxe/server';
-import { MessageContextService } from '@aztec/pxe/simulator';
+import {
+  type AnchorBlockStore,
+  ContractClassService,
+  type ContractStore,
+  ContractSyncService,
+  type NoteStore,
+} from '@aztec/pxe/server';
+import { TxResolverService } from '@aztec/pxe/simulator';
 import { L2Block, type L2TipsProvider } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
@@ -29,7 +35,8 @@ export class TXEStateMachine {
     public archiver: TXEArchiver,
     public anchorBlockStore: AnchorBlockStore,
     public contractSyncService: ContractSyncService,
-    public messageContextService: MessageContextService,
+    public contractClassService: ContractClassService,
+    public txResolver: TxResolverService,
   ) {}
 
   public static async create(
@@ -42,55 +49,63 @@ export class TXEStateMachine {
     const aztecNodeConfig = {} as AztecNodeConfig;
 
     const log = createLogger('txe_node');
-    const node = new AztecNodeService(
-      aztecNodeConfig,
-      new DummyP2P(),
-      archiver,
-      archiver,
-      archiver,
-      archiver,
-      synchronizer,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      async () => {},
-      VERSION,
-      CHAIN_ID,
-      new TXEGlobalVariablesBuilder(),
-      new TXEFeeProvider(),
-      new MockEpochCache(),
-      PACKAGE_VERSION,
-      new TestCircuitVerifier(),
-      new TestCircuitVerifier(),
-      undefined,
+    const node = new AztecNodeService({
+      config: aztecNodeConfig,
+      p2pClient: new DummyP2P(),
+      blockSource: archiver,
+      logsSource: archiver,
+      contractDataSource: archiver,
+      l1ToL2MessageSource: archiver,
+      worldStateSynchronizer: synchronizer,
+      sequencer: undefined,
+      proverNode: undefined,
+      slasherClient: undefined,
+      validatorsSentinel: undefined,
+      stopStartedWatchers: async () => {},
+      l1ChainId: CHAIN_ID,
+      version: VERSION,
+      globalVariableBuilder: new TXEGlobalVariablesBuilder(),
+      rollupContract: undefined,
+      feeProvider: new TXEFeeProvider(),
+      epochCache: new MockEpochCache(),
+      packageVersion: PACKAGE_VERSION,
+      peerProofVerifier: new TestCircuitVerifier(),
+      rpcProofVerifier: new TestCircuitVerifier(),
+      telemetry: undefined,
       log,
-    );
+    });
 
+    const contractClassService = new ContractClassService(node, contractStore);
     const contractSyncService = new ContractSyncService(
       node,
       contractStore,
+      contractClassService,
       noteStore,
       createLogger('txe:contract_sync'),
     );
 
-    const messageContextService = new MessageContextService(node);
+    const txResolver = new TxResolverService(node);
 
-    return new this(node, synchronizer, archiver, anchorBlockStore, contractSyncService, messageContextService);
+    return new this(
+      node,
+      synchronizer,
+      archiver,
+      anchorBlockStore,
+      contractSyncService,
+      contractClassService,
+      txResolver,
+    );
   }
 
   /** Returns an {@link L2TipsProvider} backed by this node's chain tips. */
   public get l2TipsProvider(): L2TipsProvider {
     const node = this.node;
     return {
-      getL2Tips: async () => {
-        const tips = await node.getChainTips();
-        return { ...tips, proposedCheckpoint: tips.checkpointed };
-      },
+      getL2Tips: () => node.getChainTips(),
     };
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2Block, l1ToL2Messages: Fr[] = []) {
     // Create a checkpoint from the block manually.
     // TXE uses 1-block-per-checkpoint for testing simplicity, so we can use block number as checkpoint number.
     // This uses the deprecated fromBlockNumber method intentionally for the TXE testing environment.
@@ -109,6 +124,7 @@ export class TXEStateMachine {
         feeRecipient: block.header.globalVariables.feeRecipient,
         gasFees: block.header.globalVariables.gasFees,
         totalManaUsed: block.header.totalManaUsed,
+        accumulatedFees: block.header.totalFees,
       }),
       [block],
       checkpointNumber,
@@ -127,7 +143,7 @@ export class TXEStateMachine {
     this.contractSyncService.wipe();
 
     await Promise.all([
-      this.synchronizer.handleL2Block(block),
+      this.synchronizer.handleL2Block(block, l1ToL2Messages),
       this.archiver.addCheckpoints([publishedCheckpoint], undefined),
       this.anchorBlockStore.setHeader(block.header),
     ]);

package/src/state_machine/synchronizer.ts

@@ -1,5 +1,6 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { BlockHash, L2Block } from '@aztec/stdlib/block';
 import type {
@@ -23,10 +24,10 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return new this(nativeWorldStateService);
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2Block, l1ToL2Messages: Fr[] = []) {
     await this.nativeWorldStateService.handleL2BlockAndMessages(
       block,
-      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
+      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
     );
 
     this.blockNumber = block.header.globalVariables.blockNumber;
@@ -57,6 +58,11 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return this.nativeWorldStateService.getSnapshot(BlockNumber(blockNumber));
   }
 
+  /** Gets a snapshot at the given block number. The TXE has no reorgs, so the fork hash is not verified. */
+  public getVerifiedSnapshot(blockNumber: number, _blockHash: BlockHash): Promise<MerkleTreeReadOperations> {
+    return Promise.resolve(this.getSnapshot(blockNumber));
+  }
+
   /** Backups the db to the target path. */
   public backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>> {
     return this.nativeWorldStateService.backupTo(dstPath, compact);