@aztec/txe 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/state_machine/archiver.ts

@@ -0,0 +1,119 @@
+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,
+  GENESIS_BLOCK_HEADER_HASH,
+  type L2BlockId,
+  type L2TipId,
+  type L2Tips,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { BlockHeader } from '@aztec/stdlib/tx';
+
+/**
+ * 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.stores);
+
+  constructor(db: AztecAsyncKVStore) {
+    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> {
+    await this.updater.addCheckpoints(checkpoints, result);
+  }
+
+  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 getL1Constants(): Promise<L1RollupConstants> {
+    // 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 }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
+  }
+
+  public getL1Timestamp(): Promise<bigint | undefined> {
+    throw new Error('TXE Archiver does not implement "getL1Timestamp"');
+  }
+
+  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 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 = 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.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}`);
+    }
+    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,
+      proposedCheckpoint: tipId,
+    };
+  }
+
+  public getSyncedL2SlotNumber(): Promise<SlotNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2SlotNumber"');
+  }
+
+  public getSyncedL2EpochNumber(): Promise<EpochNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2EpochNumber"');
+  }
+
+  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
+    throw new Error('TXE Archiver does not implement "isEpochComplete"');
+  }
+
+  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

@@ -0,0 +1,247 @@
+import type { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
+import type {
+  AuthRequest,
+  ENR,
+  P2P,
+  P2PBlockReceivedCallback,
+  P2PCheckpointAttestationCallback,
+  P2PCheckpointReceivedCallback,
+  P2PConfig,
+  P2PDuplicateAttestationCallback,
+  P2PDuplicateProposalCallback,
+  P2PSyncState,
+  PeerId,
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  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,
+  CheckpointProposalCore,
+  TopicType,
+} from '@aztec/stdlib/p2p';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+
+export class DummyP2P implements P2P {
+  public validateTxsReceivedInBlockProposal(_txs: Tx[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public clear(): Promise<void> {
+    throw new Error('DummyP2P does not implement "clear".');
+  }
+
+  public getPendingTxs(): Promise<Tx[]> {
+    throw new Error('DummyP2P does not implement "getPendingTxs"');
+  }
+
+  public getEncodedEnr(): Promise<string | undefined> {
+    throw new Error('DummyP2P does not implement "getEncodedEnr"');
+  }
+
+  public getPeers(_includePending?: boolean): Promise<PeerInfo[]> {
+    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 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)[]> {
+    throw new Error('DummyP2P does not implement "requestTxs"');
+  }
+
+  public requestTxByHash(_txHash: TxHash): Promise<Tx | undefined> {
+    throw new Error('DummyP2P does not implement "requestTxByHash"');
+  }
+
+  public sendTx(_tx: Tx): Promise<void> {
+    throw new Error('DummyP2P does not implement "sendTx"');
+  }
+
+  public handleFailedExecution(_txHashes: TxHash[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "handleFailedExecution"');
+  }
+
+  public getTxByHashFromPool(_txHash: TxHash): Promise<Tx | undefined> {
+    throw new Error('DummyP2P does not implement "getTxByHashFromPool"');
+  }
+
+  public getTxByHash(_txHash: TxHash): Promise<Tx | undefined> {
+    throw new Error('DummyP2P does not implement "getTxByHash"');
+  }
+
+  public getArchivedTxByHash(_txHash: TxHash): Promise<Tx | undefined> {
+    throw new Error('DummyP2P does not implement "getArchivedTxByHash"');
+  }
+
+  public getTxStatus(_txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+    // 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"');
+  }
+
+  public start(): Promise<void> {
+    throw new Error('DummyP2P does not implement "start"');
+  }
+
+  public stop(): Promise<void> {
+    throw new Error('DummyP2P does not implement "stop"');
+  }
+
+  public isReady(): boolean {
+    throw new Error('DummyP2P does not implement "isReady"');
+  }
+
+  public getStatus(): Promise<P2PSyncState> {
+    throw new Error('DummyP2P does not implement "getStatus"');
+  }
+
+  public getEnr(): ENR | undefined {
+    throw new Error('DummyP2P does not implement "getEnr"');
+  }
+
+  public isP2PClient(): true {
+    throw new Error('DummyP2P does not implement "isP2PClient"');
+  }
+
+  public getTxProvider(): ITxProvider {
+    throw new Error('DummyP2P does not implement "getTxProvider"');
+  }
+
+  public getTxsByHash(_txHashes: TxHash[]): Promise<Tx[]> {
+    throw new Error('DummyP2P does not implement "getTxsByHash"');
+  }
+
+  public getCheckpointAttestationsForSlot(
+    _slot: SlotNumber,
+    _proposalPayloadHash?: CheckpointProposalHash,
+  ): Promise<CheckpointAttestation[]> {
+    throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
+  }
+
+  public addOwnCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addOwnCheckpointAttestations"');
+  }
+
+  public getProposalsForSlot(_slot: SlotNumber): Promise<{
+    blockProposals: BlockProposal[];
+    checkpointProposals: CheckpointProposalCore[];
+  }> {
+    return Promise.resolve({ blockProposals: [], checkpointProposals: [] });
+  }
+
+  public getL2BlockHash(_number: number): Promise<string | undefined> {
+    throw new Error('DummyP2P does not implement "getL2BlockHash"');
+  }
+
+  public updateP2PConfig(_config: Partial<P2PConfig>): Promise<void> {
+    throw new Error('DummyP2P does not implement "updateP2PConfig"');
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    throw new Error('DummyP2P does not implement "getL2Tips"');
+  }
+
+  public handleBlockStreamEvent(_event: L2BlockStreamEvent): Promise<void> {
+    throw new Error('DummyP2P does not implement "handleBlockStreamEvent"');
+  }
+
+  public sync() {
+    throw new Error('DummyP2P does not implement "sync"');
+  }
+
+  public getTxsByHashFromPool(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    throw new Error('DummyP2P does not implement "getTxsByHashFromPool"');
+  }
+
+  public hasTxsInPool(_txHashes: TxHash[]): Promise<boolean[]> {
+    throw new Error('DummyP2P does not implement "hasTxsInPool"');
+  }
+
+  public getSyncedLatestBlockNum(): Promise<number> {
+    throw new Error('DummyP2P does not implement "getSyncedLatestBlockNum"');
+  }
+
+  public getSyncedProvenBlockNum(): Promise<number> {
+    throw new Error('DummyP2P does not implement "getSyncedProvenBlockNum"');
+  }
+
+  public getSyncedLatestSlot(): Promise<bigint> {
+    throw new Error('DummyP2P does not implement "getSyncedLatestSlot"');
+  }
+
+  protectTxs(_txHashes: TxHash[], _blockHeader: BlockHeader): Promise<TxHash[]> {
+    throw new Error('DummyP2P does not implement "protectTxs".');
+  }
+
+  prepareForSlot(_slotNumber: SlotNumber): Promise<void> {
+    return Promise.resolve();
+  }
+
+  addReqRespSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
+    throw new Error('DummyP2P does not implement "addReqRespSubProtocol".');
+  }
+  handleAuthRequestFromPeer(_authRequest: AuthRequest, _peerId: PeerId): Promise<StatusMessage> {
+    throw new Error('DummyP2P does not implement "handleAuthRequestFromPeer".');
+  }
+
+  //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 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

@@ -0,0 +1,53 @@
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
+import { BlockNumber, 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';
+
+/** 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 getPredictedMinFees(): Promise<GasFees[]> {
+    return Promise.resolve(times(FEE_ORACLE_LAG, () => new GasFees(0, 0)));
+  }
+}
+
+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,
+    _slotNumber: SlotNumber,
+    _simulationOverridesPlan?: SimulationOverridesPlan,
+  ): 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

@@ -0,0 +1,135 @@
+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 AnchorBlockStore, type ContractStore, ContractSyncService, type NoteStore } from '@aztec/pxe/server';
+import { MessageContextService } 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 { TXEArchiver } from './archiver.js';
+import { DummyP2P } from './dummy_p2p_client.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(
+    public node: AztecNode,
+    public synchronizer: TXESynchronizer,
+    public archiver: TXEArchiver,
+    public anchorBlockStore: AnchorBlockStore,
+    public contractSyncService: ContractSyncService,
+    public messageContextService: MessageContextService,
+  ) {}
+
+  public static async create(
+    archiver: TXEArchiver,
+    anchorBlockStore: AnchorBlockStore,
+    contractStore: ContractStore,
+    noteStore: NoteStore,
+  ) {
+    const synchronizer = await TXESynchronizer.create();
+    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,
+      log,
+    );
+
+    const contractSyncService = new ContractSyncService(
+      node,
+      contractStore,
+      noteStore,
+      createLogger('txe:contract_sync'),
+    );
+
+    const messageContextService = new MessageContextService(node);
+
+    return new this(node, synchronizer, archiver, anchorBlockStore, contractSyncService, messageContextService);
+  }
+
+  /** 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 };
+      },
+    };
+  }
+
+  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.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockStore.setHeader(block.header),
+    ]);
+  }
+}

package/src/state_machine/mock_epoch_cache.ts

@@ -0,0 +1,107 @@
+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.
+ * Since in TXE we don't validate transactions, mock suffices here.
+ */
+export class MockEpochCache implements EpochCacheInterface {
+  getCommittee(_slot: SlotTag = 'now'): Promise<EpochCommitteeInfo> {
+    return Promise.resolve({
+      committee: undefined,
+      seed: 0n,
+      epoch: EpochNumber.ZERO,
+      isEscapeHatchOpen: false,
+    });
+  }
+
+  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,
+      slot: SlotNumber(0),
+      ts: 0n,
+      nowMs: 0n,
+    };
+  }
+
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    return {
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
+      ts: 0n,
+      nowSeconds: 0n,
+    };
+  }
+
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    return this.getEpochAndSlotInNextL1Slot();
+  }
+
+  getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
+    return '0x00';
+  }
+
+  computeProposerIndex(_slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, _size: bigint): bigint {
+    return 0n;
+  }
+
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      currentSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      targetSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  isInCommittee(_slot: SlotTag, _validator: EthAddress): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getRegisteredValidators(): Promise<EthAddress[]> {
+    return Promise.resolve([]);
+  }
+
+  filterInCommittee(_slot: SlotTag, _validators: EthAddress[]): Promise<EthAddress[]> {
+    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;
+  }
+}