@aztec/txe 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/src/state_machine/archiver.ts

@@ -1,263 +1,112 @@
-import { ArchiverStoreHelper, KVArchiverDataStore } from '@aztec/archiver';
+import { ArchiverDataSourceBase, ArchiverDataStoreUpdater, createArchiverDataStores } from '@aztec/archiver';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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 { isDefined } from '@aztec/foundation/types';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
-  CommitteeAttestation,
-  L2Block,
+  type CheckpointId,
+  GENESIS_BLOCK_HEADER_HASH,
   type L2BlockId,
-  type L2BlockNew,
-  type L2BlockSource,
+  type L2TipId,
   type L2Tips,
-  PublishedL2Block,
-  type ValidateBlockResult,
+  type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+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';
+import { BlockHeader } from '@aztec/stdlib/tx';
 
-// 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);
-  }
+/**
+ * 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);
 
-  /**
-   * 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"');
+  constructor(db: AztecAsyncKVStore) {
+    super(
+      createArchiverDataStores(db, GENESIS_BLOCK_HEADER_HASH),
+      undefined,
+      BlockHeader.empty(),
+      GENESIS_BLOCK_HEADER_HASH,
+      new Fr(GENESIS_ARCHIVE_ROOT),
+    );
   }
 
-  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
-    throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
+  public async addCheckpoints(checkpoints: PublishedCheckpoint[], result?: ValidateCheckpointResult): Promise<void> {
+    await this.updater.addCheckpoints(checkpoints, result);
   }
 
-  public getL2EpochNumber(): Promise<EpochNumber> {
-    throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
+  public getRollupAddress(): Promise<EthAddress> {
+    throw new Error('TXE Archiver does not implement "getRollupAddress"');
   }
 
-  public getCheckpointsForEpoch(_epochNumber: EpochNumber): Promise<Checkpoint[]> {
-    throw new Error('TXE Archiver does not implement "getCheckpointsForEpoch"');
+  public getRegistryAddress(): Promise<EthAddress> {
+    throw new Error('TXE Archiver does not implement "getRegistryAddress"');
   }
 
-  public getBlocksForEpoch(_epochNumber: EpochNumber): Promise<L2Block[]> {
-    throw new Error('TXE Archiver does not implement "getBlocksForEpoch"');
+  public getL1Constants(): Promise<L1RollupConstants> {
+    throw new Error('TXE Archiver does not implement "getL1Constants"');
   }
 
-  public getBlockHeadersForEpoch(_epochNumber: EpochNumber): Promise<BlockHeader[]> {
-    throw new Error('TXE Archiver does not implement "getBlockHeadersForEpoch"');
+  public getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
   }
 
-  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
-    throw new Error('TXE Archiver does not implement "isEpochComplete"');
+  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 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 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 {
-      latest: { number, hash } as L2BlockId,
-      proven: { number, hash } as L2BlockId,
-      finalized: { number, hash } as L2BlockId,
+      proposed: blockId,
+      proven: tipId,
+      finalized: tipId,
+      checkpointed: tipId,
+      proposedCheckpoint: tipId,
     };
   }
 
-  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 getSyncedL2SlotNumber(): Promise<SlotNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2SlotNumber"');
   }
 
-  public isPendingChainInvalid(): Promise<boolean> {
-    return Promise.resolve(false);
+  public getSyncedL2EpochNumber(): Promise<EpochNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2EpochNumber"');
   }
 
-  public override getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
-    return Promise.resolve({ valid: true });
+  public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
+    throw new Error('TXE Archiver does not implement "isEpochComplete"');
   }
 
-  getPublishedBlockByHash(_blockHash: Fr): Promise<PublishedL2Block | undefined> {
-    throw new Error('Method not implemented.');
-  }
-  getPublishedBlockByArchive(_archive: Fr): Promise<PublishedL2Block | undefined> {
-    throw new Error('Method not implemented.');
+  public syncImmediate(): Promise<void> {
+    throw new Error('TXE Archiver does not implement "syncImmediate"');
   }
 }

package/src/state_machine/dummy_p2p_client.ts

@@ -1,28 +1,33 @@
-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,
   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';
+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 broadcastAttestations(_attestations: BlockAttestation[]): Promise<void> {
-    return Promise.resolve();
-  }
-
-  public validate(_txs: Tx[]): Promise<void> {
+  public validateTxsReceivedInBlockProposal(_txs: Tx[]): Promise<void> {
     return Promise.resolve();
   }
 
@@ -42,14 +47,34 @@ 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 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"');
   }
@@ -62,8 +87,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> {
@@ -88,6 +113,10 @@ export class DummyP2P implements P2P {
     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"');
   }
@@ -116,20 +145,30 @@ export class DummyP2P implements P2P {
     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 getAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<BlockAttestation[]> {
-    throw new Error('DummyP2P does not implement "getAttestationForSlot"');
+  public getCheckpointAttestationsForSlot(
+    _slot: SlotNumber,
+    _proposalPayloadHash?: CheckpointProposalHash,
+  ): Promise<CheckpointAttestation[]> {
+    throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
   }
 
-  public deleteAttestation(_attestation: BlockAttestation): Promise<void> {
-    return Promise.resolve();
+  public addOwnCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addOwnCheckpointAttestations"');
   }
 
-  public addAttestations(_attestations: BlockAttestation[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "addAttestations"');
+  public getProposalsForSlot(_slot: SlotNumber): Promise<{
+    blockProposals: BlockProposal[];
+    checkpointProposals: CheckpointProposalCore[];
+  }> {
+    return Promise.resolve({ blockProposals: [], checkpointProposals: [] });
   }
 
   public getL2BlockHash(_number: number): Promise<string | undefined> {
@@ -152,14 +191,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"');
   }
@@ -168,10 +199,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"');
   }
@@ -184,15 +211,15 @@ 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(
-    _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> {
@@ -201,4 +228,20 @@ 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 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,15 +1,29 @@
+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 { 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,
+  type FeeProvider,
+  type GlobalVariableBuilder,
+  GlobalVariables,
+} from '@aztec/stdlib/tx';
 
-export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
-  public getCurrentBaseFees(): Promise<GasFees> {
+/** 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,
@@ -23,6 +37,7 @@ export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,
     _slotNumber: SlotNumber,
+    _simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables> {
     const vars = makeGlobalVariables();
     return Promise.resolve({