@aztec/txe 0.0.1-commit.96dac018d → 0.0.1-commit.9a89641

package/src/state_machine/archiver.ts

@@ -1,12 +1,20 @@
-import { ArchiverDataSourceBase, ArchiverDataStoreUpdater, KVArchiverDataStore } from '@aztec/archiver';
+import { ArchiverDataSourceBase, ArchiverDataStoreUpdater, createArchiverDataStores } from '@aztec/archiver';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { CheckpointNumber, type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { CheckpointId, L2BlockId, L2TipId, L2Tips, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import {
+  type CheckpointId,
+  GENESIS_BLOCK_HEADER_HASH,
+  type L2BlockId,
+  type L2TipId,
+  type L2Tips,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { BlockHeader } from '@aztec/stdlib/tx';
 
 /**
  * TXE Archiver implementation.
@@ -14,11 +22,16 @@ import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
  * without needing any of the extra overhead that the Archiver itself requires (i.e. an L1 client).
  */
 export class TXEArchiver extends ArchiverDataSourceBase {
-  private readonly updater = new ArchiverDataStoreUpdater(this.store);
+  private readonly updater = new ArchiverDataStoreUpdater(this.stores);
 
   constructor(db: AztecAsyncKVStore) {
-    const store = new KVArchiverDataStore(db, 9999, { epochDuration: 32 });
-    super(store);
+    super(
+      createArchiverDataStores(db, GENESIS_BLOCK_HEADER_HASH),
+      undefined,
+      BlockHeader.empty(),
+      GENESIS_BLOCK_HEADER_HASH,
+      new Fr(GENESIS_ARCHIVE_ROOT),
+    );
   }
 
   public async addCheckpoints(checkpoints: PublishedCheckpoint[], result?: ValidateCheckpointResult): Promise<void> {
@@ -34,7 +47,9 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   }
 
   public getL1Constants(): Promise<L1RollupConstants> {
-    throw new Error('TXE Archiver does not implement "getL1Constants"');
+    // The TXE has no L1, so it serves the empty constants (epochDuration=1) used throughout the TXE state machine
+    // (see mock_epoch_cache). The node calls this when assembling a mined tx receipt to derive the epoch number.
+    return Promise.resolve(EmptyL1RollupConstants);
   }
 
   public getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
@@ -48,20 +63,21 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   public async getL2Tips(): Promise<L2Tips> {
     // In TXE there is no possibility of reorgs and no blocks are ever getting proven so we just set 'latest', 'proven'
     // and 'finalized' to the latest block.
-    const blockHeader = await this.getBlockHeader('latest');
-    if (!blockHeader) {
+    const latestBlockNumber = await this.stores.blocks.getLatestL2BlockNumber();
+    if (latestBlockNumber === 0) {
+      throw new Error('L2Tips requested from TXE Archiver but no block found');
+    }
+    const latestBlockData = await this.stores.blocks.getBlockData({ number: latestBlockNumber });
+    if (!latestBlockData) {
       throw new Error('L2Tips requested from TXE Archiver but no block header found');
     }
 
-    const number = blockHeader.globalVariables.blockNumber;
-    const hash = (await blockHeader.hash()).toString();
-    const checkpointedBlock = await this.getCheckpointedBlock(number);
-    if (!checkpointedBlock) {
-      throw new Error(`L2Tips requested from TXE Archiver but no checkpointed block found for block number ${number}`);
-    }
+    const number = latestBlockData.header.globalVariables.blockNumber;
+    const hash = latestBlockData.blockHash.toString();
+
     // 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.
-    const checkpoint = await this.store.getRangeOfCheckpoints(CheckpointNumber.fromBlockNumber(number), 1);
+    const checkpoint = await this.stores.blocks.getRangeOfCheckpoints(CheckpointNumber.fromBlockNumber(number), 1);
     if (checkpoint.length === 0) {
       throw new Error(`L2Tips requested from TXE Archiver but no checkpoint found for block number ${number}`);
     }
@@ -79,12 +95,12 @@ export class TXEArchiver extends ArchiverDataSourceBase {
     };
   }
 
-  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
-    throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
+  public getSyncedL2SlotNumber(): Promise<SlotNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2SlotNumber"');
   }
 
-  public getL2EpochNumber(): Promise<EpochNumber | undefined> {
-    throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
+  public getSyncedL2EpochNumber(): Promise<EpochNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2EpochNumber"');
   }
 
   public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
@@ -94,4 +110,9 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   public syncImmediate(): Promise<void> {
     throw new Error('TXE Archiver does not implement "syncImmediate"');
   }
+
+  public getL2ToL1MembershipWitness(): Promise<undefined> {
+    // TXE doesn't drive the L2-to-L1 message flow through this archiver.
+    return Promise.resolve(undefined);
+  }
 }

package/src/state_machine/dummy_p2p_client.ts

@@ -1,23 +1,30 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
 import type {
   AuthRequest,
   ENR,
   P2P,
   P2PBlockReceivedCallback,
+  P2PCheckpointAttestationCallback,
   P2PCheckpointReceivedCallback,
   P2PConfig,
   P2PDuplicateAttestationCallback,
   P2PDuplicateProposalCallback,
+  P2POversizedProposalCallback,
   P2PSyncState,
   PeerId,
   ReqRespSubProtocol,
   ReqRespSubProtocolHandler,
-  ReqRespSubProtocolValidators,
   StatusMessage,
 } from '@aztec/p2p';
 import type { EthAddress, L2BlockStreamEvent, L2Tips } from '@aztec/stdlib/block';
 import type { ITxProvider, PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal, CheckpointAttestation, CheckpointProposal, TopicType } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposal,
+  CheckpointProposalCore,
+  TopicType,
+} from '@aztec/stdlib/p2p';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 export class DummyP2P implements P2P {
@@ -61,8 +68,12 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "registerBlockProposalHandler"');
   }
 
-  public registerCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
-    throw new Error('DummyP2P does not implement "registerCheckpointProposalHandler"');
+  public registerValidatorCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerValidatorCheckpointProposalHandler"');
+  }
+
+  public registerAllNodesCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerAllNodesCheckpointProposalHandler"');
   }
 
   public requestTxs(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
@@ -111,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"');
   }
@@ -143,7 +158,10 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getTxsByHash"');
   }
 
-  public getCheckpointAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<CheckpointAttestation[]> {
+  public getCheckpointAttestationsForSlot(
+    _slot: SlotNumber,
+    _proposalPayloadHash?: CheckpointProposalHash,
+  ): Promise<CheckpointAttestation[]> {
     throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
   }
 
@@ -151,6 +169,17 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "addOwnCheckpointAttestations"');
   }
 
+  public getProposalsForSlot(_slot: SlotNumber): Promise<{
+    blockProposals: BlockProposal[];
+    checkpointProposals: CheckpointProposalCore[];
+  }> {
+    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"');
   }
@@ -199,11 +228,7 @@ export class DummyP2P implements P2P {
     return Promise.resolve();
   }
 
-  addReqRespSubProtocol(
-    _subProtocol: ReqRespSubProtocol,
-    _handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  addReqRespSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
     throw new Error('DummyP2P does not implement "addReqRespSubProtocol".');
   }
   handleAuthRequestFromPeer(_authRequest: AuthRequest, _peerId: PeerId): Promise<StatusMessage> {
@@ -217,10 +242,18 @@ 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"');
   }
 
+  public registerCheckpointAttestationCallback(_callback: P2PCheckpointAttestationCallback): void {
+    throw new Error('DummyP2P does not implement "registerCheckpointAttestationCallback"');
+  }
+
   public hasBlockProposalsForSlot(_slot: SlotNumber): Promise<boolean> {
     throw new Error('DummyP2P does not implement "hasBlockProposalsForSlot"');
   }

package/src/state_machine/global_variable_builder.ts

@@ -1,28 +1,29 @@
-import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
+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 { GasFees } from '@aztec/stdlib/gas';
+import { FEE_ORACLE_LAG, GasFees } from '@aztec/stdlib/gas';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { type CheckpointGlobalVariables, type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
+import type { CheckpointGlobalVariables, FeeProvider, GlobalVariableBuilder } from '@aztec/stdlib/tx';
 
-export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
+/** Simple FeeProvider for TXE that returns zero fees. */
+export class TXEFeeProvider implements FeeProvider {
   public getCurrentMinFees(): Promise<GasFees> {
     return Promise.resolve(new GasFees(0, 0));
   }
 
-  public buildGlobalVariables(
-    _blockNumber: BlockNumber,
-    _coinbase: EthAddress,
-    _feeRecipient: AztecAddress,
-    _slotNumber?: SlotNumber,
-  ): Promise<GlobalVariables> {
-    return Promise.resolve(makeGlobalVariables());
+  public getPredictedMinFees(): Promise<GasFees[]> {
+    return Promise.resolve(times(FEE_ORACLE_LAG, () => new GasFees(0, 0)));
   }
+}
 
+export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
   public buildCheckpointGlobalVariables(
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,
     _slotNumber: SlotNumber,
+    _simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables> {
     const vars = makeGlobalVariables();
     return Promise.resolve({

package/src/state_machine/index.ts

@@ -3,21 +3,30 @@ 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 { L2Block } from '@aztec/stdlib/block';
+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';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
-import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { TXEArchiver } from './archiver.js';
 import { DummyP2P } from './dummy_p2p_client.js';
-import { TXEGlobalVariablesBuilder } from './global_variable_builder.js';
+import { TXEFeeProvider, TXEGlobalVariablesBuilder } from './global_variable_builder.js';
 import { MockEpochCache } from './mock_epoch_cache.js';
 import { TXESynchronizer } from './synchronizer.js';
 
 const VERSION = 1;
 const CHAIN_ID = 1;
+// Hardcoded so the bundled TXE doesn't try to read stdlib's package.json at a relative path
+// that becomes invalid once bundled
+const PACKAGE_VERSION = 'txe';
 
 export class TXEStateMachine {
   constructor(
@@ -26,6 +35,8 @@ export class TXEStateMachine {
     public archiver: TXEArchiver,
     public anchorBlockStore: AnchorBlockStore,
     public contractSyncService: ContractSyncService,
+    public contractClassService: ContractClassService,
+    public txResolver: TxResolverService,
   ) {}
 
   public static async create(
@@ -38,40 +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,
-      undefined,
-      VERSION,
-      CHAIN_ID,
-      new TXEGlobalVariablesBuilder(),
-      new MockEpochCache(),
-      getPackageVersion() ?? '',
-      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'),
     );
 
-    return new this(node, synchronizer, archiver, anchorBlockStore, contractSyncService);
+    const txResolver = new TxResolverService(node);
+
+    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: () => 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.
@@ -90,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,
@@ -108,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/mock_epoch_cache.ts

@@ -8,7 +8,7 @@ import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/ep
  * Since in TXE we don't validate transactions, mock suffices here.
  */
 export class MockEpochCache implements EpochCacheInterface {
-  getCommittee(): Promise<EpochCommitteeInfo> {
+  getCommittee(_slot: SlotTag = 'now'): Promise<EpochCommitteeInfo> {
     return Promise.resolve({
       committee: undefined,
       seed: 0n,
@@ -17,6 +17,22 @@ export class MockEpochCache implements EpochCacheInterface {
     });
   }
 
+  getSlotNow(): SlotNumber {
+    return SlotNumber(0);
+  }
+
+  getTargetSlot(): SlotNumber {
+    return SlotNumber(0);
+  }
+
+  getEpochNow(): EpochNumber {
+    return EpochNumber.ZERO;
+  }
+
+  getTargetEpoch(): EpochNumber {
+    return EpochNumber.ZERO;
+  }
+
   getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
     return {
       epoch: EpochNumber.ZERO,
@@ -26,15 +42,19 @@ export class MockEpochCache implements EpochCacheInterface {
     };
   }
 
-  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
     return {
       epoch: EpochNumber.ZERO,
       slot: SlotNumber(0),
       ts: 0n,
-      now: 0n,
+      nowSeconds: 0n,
     };
   }
 
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    return this.getEpochAndSlotInNextL1Slot();
+  }
+
   getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
@@ -50,6 +70,13 @@ export class MockEpochCache implements EpochCacheInterface {
     };
   }
 
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      targetSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
   getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
     return Promise.resolve(undefined);
   }
@@ -66,7 +93,19 @@ export class MockEpochCache implements EpochCacheInterface {
     return Promise.resolve([]);
   }
 
+  isEscapeHatchOpen(_epoch: EpochNumber): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  isEscapeHatchOpenAtSlot(_slot: SlotTag): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
   getL1Constants(): L1RollupConstants {
     return EmptyL1RollupConstants;
   }
+
+  getLagInEpochsForValidatorSet(): number {
+    return 0;
+  }
 }

package/src/state_machine/synchronizer.ts

@@ -1,7 +1,9 @@
 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 { L2Block } from '@aztec/stdlib/block';
+import { AvmSimulatorPool } from '@aztec/simulator/server';
+import type { BlockHash, L2Block } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
@@ -15,30 +17,39 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   // This works when set to 1 as well.
   private blockNumber = BlockNumber.ZERO;
 
+  /** AVM execution backend (simulator pool + CDB server) shared across all public simulations. */
+  public avmSimulator!: AvmSimulatorPool;
+
   constructor(public nativeWorldStateService: NativeWorldStateService) {}
 
   static async create() {
-    const nativeWorldStateService = await NativeWorldStateService.tmp();
+    const nativeWorldStateService = await NativeWorldStateService.ephemeral();
+
+    const synchronizer = new this(nativeWorldStateService);
 
-    return new this(nativeWorldStateService);
+    synchronizer.avmSimulator = await AvmSimulatorPool.spawn({
+      wsdbIpcPath: nativeWorldStateService.getIpcPath(),
+    });
+
+    return synchronizer;
   }
 
-  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;
   }
 
   /**
-   * Forces an immediate sync to an optionally provided minimum block number
+   * Forces an immediate sync to an optionally provided minimum block number.
    * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
-   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
+   * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public syncImmediate(_minBlockNumber?: BlockNumber, _skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber> {
+  public syncImmediate(_minBlockNumber?: BlockNumber, _blockHash?: BlockHash): Promise<BlockNumber> {
     return Promise.resolve(this.blockNumber);
   }
 
@@ -57,6 +68,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);
@@ -70,8 +86,8 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     throw new Error('TXE Synchronizer does not implement "status"');
   }
 
-  public stop(): Promise<void> {
-    throw new Error('TXE Synchronizer does not implement "stop"');
+  public async stop(): Promise<void> {
+    await this.closeIpc();
   }
 
   public stopSync(): Promise<void> {
@@ -85,4 +101,9 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   public clear(): Promise<void> {
     throw new Error('TXE Synchronizer does not implement "clear"');
   }
+
+  /** Clean up IPC resources. */
+  public async closeIpc(): Promise<void> {
+    await this.avmSimulator?.[Symbol.asyncDispose]();
+  }
 }