@aztec/txe 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/state_machine/archiver.ts

@@ -0,0 +1,263 @@
+import { ArchiverStoreHelper, KVArchiverDataStore } from '@aztec/archiver';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { isDefined } from '@aztec/foundation/types';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  CommitteeAttestation,
+  L2Block,
+  type L2BlockId,
+  type L2BlockNew,
+  type L2BlockSource,
+  type L2Tips,
+  PublishedL2Block,
+  type ValidateBlockResult,
+} from '@aztec/stdlib/block';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+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 {
+  constructor(db: AztecAsyncKVStore) {
+    super(new KVArchiverDataStore(db, 9999));
+  }
+
+  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+    if (number === 0) {
+      return undefined;
+    }
+    const publishedBlocks = await this.getPublishedBlocks(number, 1);
+    if (publishedBlocks.length === 0) {
+      return undefined;
+    }
+    return publishedBlocks[0].block;
+  }
+
+  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]> {
+    const publishedBlocks = await this.getPublishedBlocks(from, limit, proven);
+    return publishedBlocks.map(x => x.block);
+  }
+
+  public override async addCheckpoints(
+    checkpoints: PublishedCheckpoint[],
+    _result?: ValidateBlockResult,
+  ): Promise<boolean> {
+    const allBlocks = checkpoints.flatMap(ch => ch.checkpoint.blocks);
+    const opResults = await Promise.all([this.store.addLogs(allBlocks), this.store.addCheckpoints(checkpoints)]);
+
+    return opResults.every(Boolean);
+  }
+
+  /**
+   * 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<BlockNumber> {
+    return this.store.getLatestBlockNumber();
+  }
+
+  /**
+   * 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 override getProvenBlockNumber(): Promise<BlockNumber> {
+    return this.store.getProvenBlockNumber();
+  }
+
+  /**
+   * 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 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.getLatestBlockNumber();
+    }
+    if (number == 0) {
+      return undefined;
+    }
+    const publishedBlocks = await this.retrievePublishedBlocks(BlockNumber(number), 1);
+    return publishedBlocks.length === 0 ? undefined : publishedBlocks[0];
+  }
+
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]> {
+    return this.retrievePublishedBlocks(from, limit, proven);
+  }
+
+  private async retrievePublishedBlocks(
+    from: BlockNumber,
+    limit: number,
+    proven?: boolean,
+  ): Promise<PublishedL2Block[]> {
+    const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
+    const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
+    const blocks = (
+      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
+    ).filter(isDefined);
+
+    const olbBlocks: PublishedL2Block[] = [];
+    for (let i = 0; i < checkpoints.length; i++) {
+      const blockForCheckpoint = blocks[i][0];
+      const checkpoint = checkpoints[i];
+      if (proven === true && checkpoint.checkpointNumber > provenCheckpointNumber) {
+        continue;
+      }
+      const oldCheckpoint = new Checkpoint(
+        blockForCheckpoint.archive,
+        checkpoint.header,
+        [blockForCheckpoint],
+        checkpoint.checkpointNumber,
+      );
+      const oldBlock = L2Block.fromCheckpoint(oldCheckpoint);
+      const publishedBlock = new PublishedL2Block(
+        oldBlock,
+        checkpoint.l1,
+        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+      );
+      olbBlocks.push(publishedBlock);
+    }
+    return olbBlocks;
+  }
+
+  /**
+   * 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 getL2Block(number: BlockNumber | 'latest'): Promise<L2Block | undefined> {
+    return this.getPublishedBlock(number != 'latest' ? number : -1).then(b => b?.block);
+  }
+
+  /**
+   * Gets an L2 block (new format).
+   * @param number - The block number to return.
+   * @returns The requested L2 block.
+   */
+  public getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    if (number === 0) {
+      return Promise.resolve(undefined);
+    }
+    return this.store.getBlock(number);
+  }
+
+  /**
+   * 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.getLatestBlockNumber();
+    }
+    if (number === 0) {
+      return undefined;
+    }
+    const headers = await this.store.getBlockHeaders(BlockNumber(number), 1);
+    return headers.length === 0 ? undefined : headers[0];
+  }
+
+  public getBlockRange(from: number, limit: number, _proven?: boolean): Promise<L2Block[]> {
+    return this.getPublishedBlocks(BlockNumber(from), limit).then(blocks => blocks.map(b => b.block));
+  }
+
+  public getPublishedCheckpoints(_from: CheckpointNumber, _limit: number): Promise<PublishedCheckpoint[]> {
+    throw new Error('TXE Archiver does not implement "getPublishedCheckpoints"');
+  }
+
+  public getCheckpointByArchive(_archive: Fr): Promise<Checkpoint | undefined> {
+    throw new Error('TXE Archiver does not implement "getCheckpointByArchive"');
+  }
+
+  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
+  }
+
+  public getL2EpochNumber(): Promise<EpochNumber> {
+    throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
+  }
+
+  public getCheckpointsForEpoch(_epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    throw new Error('TXE Archiver does not implement "getCheckpointsForEpoch"');
+  }
+
+  public getBlocksForEpoch(_epochNumber: EpochNumber): Promise<L2Block[]> {
+    throw new Error('TXE Archiver does not implement "getBlocksForEpoch"');
+  }
+
+  public getBlockHeadersForEpoch(_epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    throw new Error('TXE Archiver does not implement "getBlockHeadersForEpoch"');
+  }
+
+  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
+    throw new Error('TXE Archiver does not implement "isEpochComplete"');
+  }
+
+  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');
+    }
+
+    const number = blockHeader.globalVariables.blockNumber;
+    const hash = (await blockHeader.hash()).toString();
+    return {
+      latest: { number, hash } as L2BlockId,
+      proven: { number, hash } as L2BlockId,
+      finalized: { number, hash } as L2BlockId,
+    };
+  }
+
+  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 });
+  }
+
+  getPublishedBlockByHash(_blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    throw new Error('Method not implemented.');
+  }
+  getPublishedBlockByArchive(_archive: Fr): Promise<PublishedL2Block | undefined> {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/state_machine/dummy_p2p_client.ts

@@ -0,0 +1,204 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type {
+  AuthRequest,
+  ENR,
+  P2P,
+  P2PBlockReceivedCallback,
+  P2PConfig,
+  P2PSyncState,
+  PeerId,
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolValidators,
+  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';
+
+export class DummyP2P implements P2P {
+  public broadcastAttestations(_attestations: BlockAttestation[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public validate(_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 broadcastProposal(_proposal: BlockProposal): Promise<void> {
+    throw new Error('DummyP2P does not implement "broadcastProposal"');
+  }
+
+  public registerBlockProposalHandler(_handler: P2PBlockReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerBlockProposalHandler"');
+  }
+
+  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 deleteTxs(_txHashes: TxHash[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "deleteTxs"');
+  }
+
+  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 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 getTxsByHash(_txHashes: TxHash[]): Promise<Tx[]> {
+    throw new Error('DummyP2P does not implement "getTxsByHash"');
+  }
+
+  public getAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<BlockAttestation[]> {
+    throw new Error('DummyP2P does not implement "getAttestationForSlot"');
+  }
+
+  public deleteAttestation(_attestation: BlockAttestation): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public addAttestations(_attestations: BlockAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addAttestations"');
+  }
+
+  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 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"');
+  }
+
+  public hasTxsInPool(_txHashes: TxHash[]): Promise<boolean[]> {
+    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"');
+  }
+
+  public getSyncedProvenBlockNum(): Promise<number> {
+    throw new Error('DummyP2P does not implement "getSyncedProvenBlockNum"');
+  }
+
+  public getSyncedLatestSlot(): Promise<bigint> {
+    throw new Error('DummyP2P does not implement "getSyncedLatestSlot"');
+  }
+
+  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "markTxsAsNonEvictable".');
+  }
+
+  addReqRespSubProtocol(
+    _subProtocol: ReqRespSubProtocol,
+    _handler: ReqRespSubProtocolHandler,
+    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): 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 {}
+}

package/src/state_machine/global_variable_builder.ts

@@ -0,0 +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 CheckpointGlobalVariables, type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
+
+export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
+  public getCurrentBaseFees(): 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 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

@@ -0,0 +1,78 @@
+import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { TestCircuitVerifier } from '@aztec/bb-prover/test';
+import { createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AnchorBlockDataProvider } from '@aztec/pxe/server';
+import { L2Block } from '@aztec/stdlib/block';
+import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+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 { MockEpochCache } from './mock_epoch_cache.js';
+import { TXESynchronizer } from './synchronizer.js';
+
+const VERSION = 1;
+const CHAIN_ID = 1;
+
+export class TXEStateMachine {
+  constructor(
+    public node: AztecNode,
+    public synchronizer: TXESynchronizer,
+    public archiver: TXEArchiver,
+    public anchorBlockDataProvider: AnchorBlockDataProvider,
+  ) {}
+
+  public static async create(db: AztecAsyncKVStore) {
+    const archiver = new TXEArchiver(db);
+    const synchronizer = await TXESynchronizer.create();
+    const anchorBlockDataProvider = new AnchorBlockDataProvider(db);
+
+    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,
+      VERSION,
+      CHAIN_ID,
+      new TXEGlobalVariablesBuilder(),
+      new MockEpochCache(),
+      getPackageVersion() ?? '',
+      new TestCircuitVerifier(),
+      undefined,
+      log,
+    );
+
+    return new this(node, synchronizer, archiver, anchorBlockDataProvider);
+  }
+
+  public async handleL2Block(block: L2Block) {
+    const checkpoint = block.toCheckpoint();
+    const publishedCheckpoint = new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(
+        BigInt(block.header.globalVariables.blockNumber),
+        block.header.globalVariables.timestamp,
+        block.header.globalVariables.blockNumber.toString(),
+      ),
+      [],
+    );
+    await Promise.all([
+      this.synchronizer.handleL2Block(block.toL2Block()),
+      this.archiver.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockDataProvider.setHeader(block.getBlockHeader()),
+    ]);
+  }
+}

package/src/state_machine/mock_epoch_cache.ts

@@ -0,0 +1,68 @@
+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';
+
+/**
+ * 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(): Promise<EpochCommitteeInfo> {
+    return Promise.resolve({
+      committee: undefined,
+      seed: 0n,
+      epoch: EpochNumber.ZERO,
+    });
+  }
+
+  getEpochAndSlotNow(): EpochAndSlot {
+    return {
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
+      ts: 0n,
+    };
+  }
+
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
+    return {
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
+      ts: 0n,
+      now: 0n,
+    };
+  }
+
+  getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
+    return '0x00';
+  }
+
+  computeProposerIndex(_slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, _size: bigint): bigint {
+    return 0n;
+  }
+
+  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
+    currentProposer: EthAddress | undefined;
+    nextProposer: EthAddress | undefined;
+    currentSlot: SlotNumber;
+    nextSlot: SlotNumber;
+  }> {
+    return Promise.resolve({
+      currentProposer: undefined,
+      nextProposer: undefined,
+      currentSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    });
+  }
+
+  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([]);
+  }
+}