@aztec/txe 0.0.1-commit.b655e406 → 0.0.1-commit.c0b82b2

package/src/state_machine/archiver.ts

@@ -1,151 +1,97 @@
-import { ArchiverStoreHelper, KVArchiverDataStore, type PublishedL2Block } from '@aztec/archiver';
+import { ArchiverDataSourceBase, ArchiverDataStoreUpdater, KVArchiverDataStore } 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 { Fr } from '@aztec/foundation/fields';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block, L2BlockSource, L2Tips, ValidateBlockResult } from '@aztec/stdlib/block';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { CheckpointId, L2BlockId, L2TipId, L2Tips, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
 
-// We are extending the ArchiverDataStoreHelper here because it provides most of the endpoints needed by the
-// node for reading from and writing to state, without needing any of the extra overhead that the Archiver itself
-// requires (i.e. an L1 client)
-export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
+/**
+ * TXE Archiver implementation.
+ * Provides most of the endpoints needed by the node for reading from and writing to state,
+ * 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);
+
   constructor(db: AztecAsyncKVStore) {
-    super(new KVArchiverDataStore(db, 9999));
+    const store = new KVArchiverDataStore(db, 9999, { epochDuration: 32 });
+    super(store);
   }
 
-  public override async addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
-    const opResults = await Promise.all([
-      this.store.addLogs(blocks.map(block => block.block)),
-      this.store.addBlocks(blocks),
-    ]);
-
-    return opResults.every(Boolean);
+  public async addCheckpoints(checkpoints: PublishedCheckpoint[], result?: ValidateCheckpointResult): Promise<void> {
+    await this.updater.addCheckpoints(checkpoints, result);
   }
 
-  /**
-   * Gets the number of the latest L2 block processed by the block source implementation.
-   * @returns The number of the latest L2 block processed by the block source implementation.
-   */
-  public getBlockNumber(): Promise<number> {
-    return this.store.getSynchedL2BlockNumber();
+  public getRollupAddress(): Promise<EthAddress> {
+    throw new Error('TXE Archiver does not implement "getRollupAddress"');
   }
 
-  /**
-   * Gets the number of the latest L2 block proven seen by the block source implementation.
-   * @returns The number of the latest L2 block proven seen by the block source implementation.
-   */
-  public getProvenBlockNumber(): Promise<number> {
-    return this.store.getSynchedL2BlockNumber();
+  public getRegistryAddress(): Promise<EthAddress> {
+    throw new Error('TXE Archiver does not implement "getRegistryAddress"');
   }
 
-  /**
-   * Gets a published l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */
-  public override async getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
-    // If the number provided is -ve, then return the latest block.
-    if (number < 0) {
-      number = await this.store.getSynchedL2BlockNumber();
-    }
-    if (number == 0) {
-      return undefined;
-    }
-    const blocks = await this.store.getPublishedBlocks(number, 1);
-    return blocks.length === 0 ? undefined : blocks[0];
+  public getL1Constants(): Promise<L1RollupConstants> {
+    throw new Error('TXE Archiver does not implement "getL1Constants"');
   }
 
-  /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */
-  public getBlock(number: number | 'latest'): Promise<L2Block | undefined> {
-    return this.getPublishedBlock(number != 'latest' ? number : -1).then(block => block?.block);
+  public getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
   }
 
-  /**
-   * Gets an l2 block header.
-   * @param number - The block number to return or 'latest' for the most recent one.
-   * @returns The requested L2 block header.
-   */
-  public async getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    if (number === 'latest') {
-      number = await this.store.getSynchedL2BlockNumber();
-    }
-    if (number === 0) {
-      return undefined;
-    }
-    const headers = await this.store.getBlockHeaders(number, 1);
-    return headers.length === 0 ? undefined : headers[0];
+  public getL1Timestamp(): Promise<bigint | undefined> {
+    throw new Error('TXE Archiver does not implement "getL1Timestamp"');
   }
 
-  public getBlocks(from: number, limit: number, _proven?: boolean): Promise<L2Block[]> {
-    return this.getPublishedBlocks(from, limit).then(blocks => blocks.map(b => b.block));
-  }
+  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) {
+      throw new Error('L2Tips requested from TXE Archiver but no block header found');
+    }
 
-  public getL2SlotNumber(): Promise<bigint> {
+    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}`);
+    }
+    // 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);
+    if (checkpoint.length === 0) {
+      throw new Error(`L2Tips requested from TXE Archiver but no checkpoint found for block number ${number}`);
+    }
+    const blockId: L2BlockId = { number, hash };
+    const checkpointId: CheckpointId = {
+      number: checkpoint[0].checkpointNumber,
+      hash: checkpoint[0].header.hash().toString(),
+    };
+    const tipId: L2TipId = { block: blockId, checkpoint: checkpointId };
+    return {
+      proposed: blockId,
+      proven: tipId,
+      finalized: tipId,
+      checkpointed: tipId,
+    };
+  }
+
+  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
     throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
   }
 
-  public getL2EpochNumber(): Promise<bigint> {
+  public getL2EpochNumber(): Promise<EpochNumber | undefined> {
     throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
   }
 
-  public getBlocksForEpoch(_epochNumber: bigint): Promise<L2Block[]> {
-    throw new Error('TXE Archiver does not implement "getBlocksForEpoch"');
-  }
-
-  public getBlockHeadersForEpoch(_epochNumber: bigint): Promise<BlockHeader[]> {
-    throw new Error('TXE Archiver does not implement "getBlockHeadersForEpoch"');
-  }
-
-  public isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('TXE Archiver does not implement "isEpochComplete"');
   }
 
-  public getL2Tips(): Promise<L2Tips> {
-    throw new Error('TXE Archiver does not implement "getL2Tips"');
-  }
-
-  public getL1Constants(): Promise<L1RollupConstants> {
-    throw new Error('TXE Archiver does not implement "getL2Constants"');
-  }
-
-  public getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
-    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
-  }
-
   public syncImmediate(): Promise<void> {
     throw new Error('TXE Archiver does not implement "syncImmediate"');
   }
-
-  public getContract(_address: AztecAddress, _timestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined> {
-    throw new Error('TXE Archiver does not implement "getContract"');
-  }
-
-  public getRollupAddress(): Promise<EthAddress> {
-    throw new Error('TXE Archiver does not implement "getRollupAddress"');
-  }
-
-  public getRegistryAddress(): Promise<EthAddress> {
-    throw new Error('TXE Archiver does not implement "getRegistryAddress"');
-  }
-
-  public getL1Timestamp(): Promise<bigint> {
-    throw new Error('TXE Archiver does not implement "getL1Timestamp"');
-  }
-
-  public isPendingChainInvalid(): Promise<boolean> {
-    return Promise.resolve(false);
-  }
-
-  public override getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
-    return Promise.resolve({ valid: true });
-  }
 }

package/src/state_machine/dummy_p2p_client.ts

@@ -1,9 +1,13 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type {
   AuthRequest,
   ENR,
   P2P,
   P2PBlockReceivedCallback,
+  P2PCheckpointReceivedCallback,
   P2PConfig,
+  P2PDuplicateAttestationCallback,
+  P2PDuplicateProposalCallback,
   P2PSyncState,
   PeerId,
   ReqRespSubProtocol,
@@ -12,12 +16,12 @@ import type {
   StatusMessage,
 } from '@aztec/p2p';
 import type { EthAddress, L2BlockStreamEvent, L2Tips } from '@aztec/stdlib/block';
-import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { ITxProvider, PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { BlockProposal, CheckpointAttestation, CheckpointProposal, TopicType } from '@aztec/stdlib/p2p';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 export class DummyP2P implements P2P {
-  public validate(_txs: Tx[]): Promise<void> {
+  public validateTxsReceivedInBlockProposal(_txs: Tx[]): Promise<void> {
     return Promise.resolve();
   }
 
@@ -37,14 +41,30 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getPeers"');
   }
 
+  public getGossipMeshPeerCount(_topicType: TopicType): Promise<number> {
+    return Promise.resolve(0);
+  }
+
   public broadcastProposal(_proposal: BlockProposal): Promise<void> {
     throw new Error('DummyP2P does not implement "broadcastProposal"');
   }
 
+  public broadcastCheckpointProposal(_proposal: CheckpointProposal): Promise<void> {
+    throw new Error('DummyP2P does not implement "broadcastCheckpointProposal"');
+  }
+
+  public broadcastCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "broadcastCheckpointAttestations"');
+  }
+
   public registerBlockProposalHandler(_handler: P2PBlockReceivedCallback): void {
     throw new Error('DummyP2P does not implement "registerBlockProposalHandler"');
   }
 
+  public registerCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerCheckpointProposalHandler"');
+  }
+
   public requestTxs(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
     throw new Error('DummyP2P does not implement "requestTxs"');
   }
@@ -57,8 +77,8 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "sendTx"');
   }
 
-  public deleteTxs(_txHashes: TxHash[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "deleteTxs"');
+  public handleFailedExecution(_txHashes: TxHash[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "handleFailedExecution"');
   }
 
   public getTxByHashFromPool(_txHash: TxHash): Promise<Tx | undefined> {
@@ -74,13 +94,19 @@ export class DummyP2P implements P2P {
   }
 
   public getTxStatus(_txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
-    throw new Error('DummyP2P does not implement "getTxStatus"');
+    // In TXE there is no concept of transactions but we need to implement this because of tagging. We return 'mined'
+    // tx status for any tx hash.
+    return Promise.resolve('mined');
   }
 
   public iteratePendingTxs(): AsyncIterableIterator<Tx> {
     throw new Error('DummyP2P does not implement "iteratePendingTxs"');
   }
 
+  public iterateEligiblePendingTxs(): AsyncIterableIterator<Tx> {
+    throw new Error('DummyP2P does not implement "iterateEligiblePendingTxs"');
+  }
+
   public getPendingTxCount(): Promise<number> {
     throw new Error('DummyP2P does not implement "getPendingTxCount"');
   }
@@ -109,20 +135,20 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "isP2PClient"');
   }
 
-  public getTxsByHash(_txHashes: TxHash[]): Promise<Tx[]> {
-    throw new Error('DummyP2P does not implement "getTxsByHash"');
+  public getTxProvider(): ITxProvider {
+    throw new Error('DummyP2P does not implement "getTxProvider"');
   }
 
-  public getAttestationsForSlot(_slot: bigint, _proposalId?: string): Promise<BlockAttestation[]> {
-    throw new Error('DummyP2P does not implement "getAttestationForSlot"');
+  public getTxsByHash(_txHashes: TxHash[]): Promise<Tx[]> {
+    throw new Error('DummyP2P does not implement "getTxsByHash"');
   }
 
-  public deleteAttestation(_attestation: BlockAttestation): Promise<void> {
-    return Promise.resolve();
+  public getCheckpointAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<CheckpointAttestation[]> {
+    throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
   }
 
-  public addAttestations(_attestations: BlockAttestation[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "addAttestations"');
+  public addOwnCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addOwnCheckpointAttestations"');
   }
 
   public getL2BlockHash(_number: number): Promise<string | undefined> {
@@ -145,14 +171,6 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "sync"');
   }
 
-  public requestTxsByHash(_txHashes: TxHash[]): Promise<Tx[]> {
-    throw new Error('DummyP2P does not implement "requestTxsByHash"');
-  }
-
-  public getTxs(_filter: 'all' | 'pending' | 'mined'): Promise<Tx[]> {
-    throw new Error('DummyP2P does not implement "getTxs"');
-  }
-
   public getTxsByHashFromPool(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
     throw new Error('DummyP2P does not implement "getTxsByHashFromPool"');
   }
@@ -161,10 +179,6 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "hasTxsInPool"');
   }
 
-  public addTxsToPool(_txs: Tx[]): Promise<number> {
-    throw new Error('DummyP2P does not implement "addTxs"');
-  }
-
   public getSyncedLatestBlockNum(): Promise<number> {
     throw new Error('DummyP2P does not implement "getSyncedLatestBlockNum"');
   }
@@ -177,8 +191,12 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getSyncedLatestSlot"');
   }
 
-  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "markTxsAsNonEvictable".');
+  protectTxs(_txHashes: TxHash[], _blockHeader: BlockHeader): Promise<TxHash[]> {
+    throw new Error('DummyP2P does not implement "protectTxs".');
+  }
+
+  prepareForSlot(_slotNumber: SlotNumber): Promise<void> {
+    return Promise.resolve();
   }
 
   addReqRespSubProtocol(
@@ -194,4 +212,16 @@ export class DummyP2P implements P2P {
 
   //This is no-op
   public registerThisValidatorAddresses(_address: EthAddress[]): void {}
+
+  public registerDuplicateProposalCallback(_callback: P2PDuplicateProposalCallback): void {
+    throw new Error('DummyP2P does not implement "registerDuplicateProposalCallback"');
+  }
+
+  public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {
+    throw new Error('DummyP2P does not implement "registerDuplicateAttestationCallback"');
+  }
+
+  public hasBlockProposalsForSlot(_slot: SlotNumber): Promise<boolean> {
+    throw new Error('DummyP2P does not implement "hasBlockProposalsForSlot"');
+  }
 }

package/src/state_machine/global_variable_builder.ts

@@ -1,20 +1,38 @@
+import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
 import { makeGlobalVariables } from '@aztec/stdlib/testing';
-import { type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
+import { type CheckpointGlobalVariables, type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
 
 export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
-  public getCurrentBaseFees(): Promise<GasFees> {
+  public getCurrentMinFees(): Promise<GasFees> {
     return Promise.resolve(new GasFees(0, 0));
   }
 
   public buildGlobalVariables(
-    _blockNumber: number,
+    _blockNumber: BlockNumber,
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,
-    _slotNumber?: bigint,
+    _slotNumber?: SlotNumber,
   ): Promise<GlobalVariables> {
     return Promise.resolve(makeGlobalVariables());
   }
+
+  public buildCheckpointGlobalVariables(
+    _coinbase: EthAddress,
+    _feeRecipient: AztecAddress,
+    _slotNumber: SlotNumber,
+  ): Promise<CheckpointGlobalVariables> {
+    const vars = makeGlobalVariables();
+    return Promise.resolve({
+      chainId: vars.chainId,
+      version: vars.version,
+      slotNumber: vars.slotNumber,
+      timestamp: vars.timestamp,
+      coinbase: vars.coinbase,
+      feeRecipient: vars.feeRecipient,
+      gasFees: vars.gasFees,
+    });
+  }
 }

package/src/state_machine/index.ts

@@ -1,10 +1,13 @@
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 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 { AztecAsyncKVStore } from '@aztec/kv-store';
-import { SyncDataProvider } from '@aztec/pxe/server';
-import { type L2Block, PublishedL2Block } from '@aztec/stdlib/block';
+import { type AnchorBlockStore, type ContractStore, ContractSyncService, type NoteStore } from '@aztec/pxe/server';
+import { L2Block } 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';
@@ -21,14 +24,17 @@ export class TXEStateMachine {
     public node: AztecNode,
     public synchronizer: TXESynchronizer,
     public archiver: TXEArchiver,
-    public syncDataProvider: SyncDataProvider,
+    public anchorBlockStore: AnchorBlockStore,
+    public contractSyncService: ContractSyncService,
   ) {}
 
-  public static async create(db: AztecAsyncKVStore) {
-    const archiver = new TXEArchiver(db);
+  public static async create(
+    archiver: TXEArchiver,
+    anchorBlockStore: AnchorBlockStore,
+    contractStore: ContractStore,
+    noteStore: NoteStore,
+  ) {
     const synchronizer = await TXESynchronizer.create();
-    const syncDataProvider = new SyncDataProvider(db);
-
     const aztecNodeConfig = {} as AztecNodeConfig;
 
     const log = createLogger('txe_node');
@@ -44,6 +50,7 @@ export class TXEStateMachine {
       undefined,
       undefined,
       undefined,
+      undefined,
       VERSION,
       CHAIN_ID,
       new TXEGlobalVariablesBuilder(),
@@ -54,24 +61,56 @@ export class TXEStateMachine {
       log,
     );
 
-    return new this(node, synchronizer, archiver, syncDataProvider);
+    const contractSyncService = new ContractSyncService(
+      node,
+      contractStore,
+      noteStore,
+      createLogger('txe:contract_sync'),
+    );
+
+    return new this(node, synchronizer, archiver, anchorBlockStore, contractSyncService);
   }
 
   public async handleL2Block(block: L2Block) {
+    // 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.
+    const checkpointNumber = CheckpointNumber.fromBlockNumber(block.number);
+    const checkpoint = new Checkpoint(
+      block.archive,
+      CheckpointHeader.from({
+        lastArchiveRoot: block.header.lastArchive.root,
+        inHash: Fr.ZERO,
+        blobsHash: Fr.ZERO,
+        blockHeadersHash: Fr.ZERO,
+        epochOutHash: Fr.ZERO,
+        slotNumber: block.header.globalVariables.slotNumber,
+        timestamp: block.header.globalVariables.timestamp,
+        coinbase: block.header.globalVariables.coinbase,
+        feeRecipient: block.header.globalVariables.feeRecipient,
+        gasFees: block.header.globalVariables.gasFees,
+        totalManaUsed: block.header.totalManaUsed,
+      }),
+      [block],
+      checkpointNumber,
+    );
+
+    const publishedCheckpoint = new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(
+        BigInt(block.header.globalVariables.blockNumber),
+        block.header.globalVariables.timestamp,
+        block.header.globalVariables.blockNumber.toString(),
+      ),
+      [],
+    );
+    // Wipe contract sync cache when anchor block changes (mirrors BlockSynchronizer behavior)
+    this.contractSyncService.wipe();
+
     await Promise.all([
       this.synchronizer.handleL2Block(block),
-      this.archiver.addBlocks([
-        PublishedL2Block.fromFields({
-          block,
-          l1: {
-            blockHash: block.header.globalVariables.blockNumber.toString(),
-            blockNumber: BigInt(block.header.globalVariables.blockNumber),
-            timestamp: block.header.globalVariables.timestamp,
-          },
-          attestations: [],
-        }),
-      ]),
-      this.syncDataProvider.setHeader(block.getBlockHeader()),
+      this.archiver.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockStore.setHeader(block.header),
     ]);
   }
 }

package/src/state_machine/mock_epoch_cache.ts

@@ -1,5 +1,7 @@
 import type { EpochAndSlot, EpochCacheInterface, EpochCommitteeInfo, SlotTag } from '@aztec/epoch-cache';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 
 /**
  * Mock implementation of the EpochCacheInterface used to satisfy dependencies of AztecNodeService.
@@ -10,47 +12,46 @@ export class MockEpochCache implements EpochCacheInterface {
     return Promise.resolve({
       committee: undefined,
       seed: 0n,
-      epoch: 0n,
+      epoch: EpochNumber.ZERO,
+      isEscapeHatchOpen: false,
     });
   }
 
-  getEpochAndSlotNow(): EpochAndSlot {
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
     return {
-      epoch: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
+      nowMs: 0n,
     };
   }
 
   getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
     return {
-      epoch: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
       now: 0n,
     };
   }
 
-  getProposerIndexEncoding(_epoch: bigint, _slot: bigint, _seed: bigint): `0x${string}` {
+  getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
 
-  computeProposerIndex(_slot: bigint, _epoch: bigint, _seed: bigint, _size: bigint): bigint {
+  computeProposerIndex(_slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, _size: bigint): bigint {
     return 0n;
   }
 
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: bigint;
-    nextSlot: bigint;
-  }> {
-    return Promise.resolve({
-      currentProposer: undefined,
-      nextProposer: undefined,
-      currentSlot: 0n,
-      nextSlot: 0n,
-    });
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      currentSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(undefined);
   }
 
   isInCommittee(_slot: SlotTag, _validator: EthAddress): Promise<boolean> {
@@ -64,4 +65,8 @@ export class MockEpochCache implements EpochCacheInterface {
   filterInCommittee(_slot: SlotTag, _validators: EthAddress[]): Promise<EthAddress[]> {
     return Promise.resolve([]);
   }
+
+  getL1Constants(): L1RollupConstants {
+    return EmptyL1RollupConstants;
+  }
 }