@aztec/txe 0.0.1-commit.e3c1de76 → 0.0.1-commit.e588bc7e5

package/src/state_machine/archiver.ts

@@ -17,7 +17,7 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   private readonly updater = new ArchiverDataStoreUpdater(this.store);
 
   constructor(db: AztecAsyncKVStore) {
-    const store = new KVArchiverDataStore(db, 9999, { epochDuration: 32 });
+    const store = new KVArchiverDataStore(db, 9999);
     super(store);
   }
 
@@ -59,6 +59,8 @@ export class TXEArchiver extends ArchiverDataSourceBase {
     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}`);
@@ -74,15 +76,16 @@ export class TXEArchiver extends ArchiverDataSourceBase {
       proven: tipId,
       finalized: tipId,
       checkpointed: tipId,
+      proposedCheckpoint: tipId,
     };
   }
 
-  public getL2SlotNumber(): Promise<SlotNumber | undefined> {
-    throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
+  public getSyncedL2SlotNumber(): Promise<SlotNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2SlotNumber"');
   }
 
-  public getL2EpochNumber(): Promise<EpochNumber | undefined> {
-    throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
+  public getSyncedL2EpochNumber(): Promise<EpochNumber | undefined> {
+    throw new Error('TXE Archiver does not implement "getSyncedL2EpochNumber"');
   }
 
   public isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {

package/src/state_machine/dummy_p2p_client.ts

@@ -6,6 +6,8 @@ import type {
   P2PBlockReceivedCallback,
   P2PCheckpointReceivedCallback,
   P2PConfig,
+  P2PDuplicateAttestationCallback,
+  P2PDuplicateProposalCallback,
   P2PSyncState,
   PeerId,
   ReqRespSubProtocol,
@@ -14,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 { BlockProposal, CheckpointAttestation, CheckpointProposal } 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();
   }
 
@@ -39,6 +41,10 @@ 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"');
   }
@@ -55,8 +61,12 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "registerBlockProposalHandler"');
   }
 
-  public registerCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
-    throw new Error('DummyP2P does not implement "registerCheckpointProposalHandler"');
+  public registerValidatorCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerValidatorCheckpointProposalHandler"');
+  }
+
+  public registerAllNodesCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerAllNodesCheckpointProposalHandler"');
   }
 
   public requestTxs(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
@@ -71,8 +81,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> {
@@ -97,6 +107,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"');
   }
@@ -125,6 +139,10 @@ 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"');
   }
@@ -133,8 +151,8 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
   }
 
-  public addCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "addCheckpointAttestations"');
+  public addOwnCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addOwnCheckpointAttestations"');
   }
 
   public getL2BlockHash(_number: number): Promise<string | undefined> {
@@ -157,14 +175,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"');
   }
@@ -173,10 +183,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"');
   }
@@ -189,8 +195,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(
@@ -206,4 +216,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

@@ -3,7 +3,12 @@ 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';
+import {
+  type BuildCheckpointGlobalVariablesOpts,
+  type CheckpointGlobalVariables,
+  type GlobalVariableBuilder,
+  GlobalVariables,
+} from '@aztec/stdlib/tx';
 
 export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
   public getCurrentMinFees(): Promise<GasFees> {
@@ -23,6 +28,7 @@ export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
     _coinbase: EthAddress,
     _feeRecipient: AztecAddress,
     _slotNumber: SlotNumber,
+    _opts?: BuildCheckpointGlobalVariablesOpts,
   ): Promise<CheckpointGlobalVariables> {
     const vars = makeGlobalVariables();
     return Promise.resolve({

package/src/state_machine/index.ts

@@ -3,8 +3,8 @@ 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 { AnchorBlockStore } from '@aztec/pxe/server';
+import { type AnchorBlockStore, type ContractStore, ContractSyncService, type NoteStore } from '@aztec/pxe/server';
+import { MessageContextService } from '@aztec/pxe/simulator';
 import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
@@ -26,13 +26,17 @@ export class TXEStateMachine {
     public synchronizer: TXESynchronizer,
     public archiver: TXEArchiver,
     public anchorBlockStore: AnchorBlockStore,
+    public contractSyncService: ContractSyncService,
+    public messageContextService: MessageContextService,
   ) {}
 
-  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 anchorBlockStore = new AnchorBlockStore(db);
-
     const aztecNodeConfig = {} as AztecNodeConfig;
 
     const log = createLogger('txe_node');
@@ -48,21 +52,35 @@ export class TXEStateMachine {
       undefined,
       undefined,
       undefined,
+      undefined,
       VERSION,
       CHAIN_ID,
       new TXEGlobalVariablesBuilder(),
       new MockEpochCache(),
       getPackageVersion() ?? '',
       new TestCircuitVerifier(),
+      new TestCircuitVerifier(),
       undefined,
       log,
     );
 
-    return new this(node, synchronizer, archiver, anchorBlockStore);
+    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);
   }
 
   public async handleL2Block(block: L2Block) {
-    // Create a checkpoint from the block manually
+    // 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({
@@ -79,7 +97,7 @@ export class TXEStateMachine {
         totalManaUsed: block.header.totalManaUsed,
       }),
       [block],
-      CheckpointNumber.fromBlockNumber(block.number),
+      checkpointNumber,
     );
 
     const publishedCheckpoint = new PublishedCheckpoint(
@@ -91,6 +109,9 @@ export class TXEStateMachine {
       ),
       [],
     );
+    // 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),

package/src/state_machine/mock_epoch_cache.ts

@@ -1,13 +1,14 @@
 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(): Promise<EpochCommitteeInfo> {
+  getCommittee(_slot: SlotTag = 'now'): Promise<EpochCommitteeInfo> {
     return Promise.resolve({
       committee: undefined,
       seed: 0n,
@@ -16,6 +17,22 @@ export class MockEpochCache implements EpochCacheInterface {
     });
   }
 
+  getSlotNow(): SlotNumber {
+    return SlotNumber(0);
+  }
+
+  getTargetSlot(): SlotNumber {
+    return SlotNumber(0);
+  }
+
+  getEpochNow(): EpochNumber {
+    return EpochNumber.ZERO;
+  }
+
+  getTargetEpoch(): EpochNumber {
+    return EpochNumber.ZERO;
+  }
+
   getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
     return {
       epoch: EpochNumber.ZERO,
@@ -25,15 +42,23 @@ export class MockEpochCache implements EpochCacheInterface {
     };
   }
 
-  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
     return {
       epoch: EpochNumber.ZERO,
       slot: SlotNumber(0),
       ts: 0n,
-      now: 0n,
+      nowSeconds: 0n,
     };
   }
 
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    return this.getEpochAndSlotInNextL1Slot();
+  }
+
+  isProposerPipeliningEnabled(): boolean {
+    return false;
+  }
+
   getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
@@ -49,6 +74,13 @@ export class MockEpochCache implements EpochCacheInterface {
     };
   }
 
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      targetSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
   getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
     return Promise.resolve(undefined);
   }
@@ -64,4 +96,16 @@ export class MockEpochCache implements EpochCacheInterface {
   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;
+  }
 }

package/src/state_machine/synchronizer.ts

@@ -1,7 +1,7 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockHash, L2Block } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
@@ -33,12 +33,12 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   }
 
   /**
-   * Forces an immediate sync to an optionally provided minimum block number
+   * Forces an immediate sync to an optionally provided minimum block number.
    * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
-   * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
+   * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public syncImmediate(_minBlockNumber?: BlockNumber, _skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber> {
+  public syncImmediate(_minBlockNumber?: BlockNumber, _blockHash?: BlockHash): Promise<BlockNumber> {
     return Promise.resolve(this.blockNumber);
   }