@aztec/txe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/state_machine/archiver.ts

@@ -13,7 +13,7 @@ import {
   type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { BlockHeader } from '@aztec/stdlib/tx';
 
 /**
@@ -47,7 +47,9 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   }
 
   public getL1Constants(): Promise<L1RollupConstants> {
-    throw new Error('TXE Archiver does not implement "getL1Constants"');
+    // 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 }> {
@@ -90,7 +92,6 @@ export class TXEArchiver extends ArchiverDataSourceBase {
       proven: tipId,
       finalized: tipId,
       checkpointed: tipId,
-      proposedCheckpoint: tipId,
     };
   }
 
@@ -109,4 +110,9 @@ export class TXEArchiver extends ArchiverDataSourceBase {
   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

@@ -9,6 +9,7 @@ import type {
   P2PConfig,
   P2PDuplicateAttestationCallback,
   P2PDuplicateProposalCallback,
+  P2POversizedProposalCallback,
   P2PSyncState,
   PeerId,
   ReqRespSubProtocol,
@@ -121,6 +122,10 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "getPendingTxCount"');
   }
 
+  public hasEligiblePendingTxs(_minCount: number): Promise<boolean> {
+    throw new Error('DummyP2P does not implement "hasEligiblePendingTxs"');
+  }
+
   public start(): Promise<void> {
     throw new Error('DummyP2P does not implement "start"');
   }
@@ -171,6 +176,10 @@ export class DummyP2P implements P2P {
     return Promise.resolve({ blockProposals: [], checkpointProposals: [] });
   }
 
+  public hasCheckpointProposalForSlot(_slot: SlotNumber): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
   public getL2BlockHash(_number: number): Promise<string | undefined> {
     throw new Error('DummyP2P does not implement "getL2BlockHash"');
   }
@@ -233,6 +242,10 @@ export class DummyP2P implements P2P {
     throw new Error('DummyP2P does not implement "registerDuplicateProposalCallback"');
   }
 
+  public registerOversizedProposalCallback(_callback: P2POversizedProposalCallback): void {
+    throw new Error('DummyP2P does not implement "registerOversizedProposalCallback"');
+  }
+
   public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {
     throw new Error('DummyP2P does not implement "registerDuplicateAttestationCallback"');
   }

package/src/state_machine/global_variable_builder.ts

@@ -1,16 +1,11 @@
 import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
-import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import 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';
+import type { CheckpointGlobalVariables, FeeProvider, GlobalVariableBuilder } from '@aztec/stdlib/tx';
 
 /** Simple FeeProvider for TXE that returns zero fees. */
 export class TXEFeeProvider implements FeeProvider {
@@ -24,15 +19,6 @@ export class TXEFeeProvider implements FeeProvider {
 }
 
 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,

package/src/state_machine/index.ts

@@ -3,8 +3,14 @@ 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 {
+  type AnchorBlockStore,
+  ContractClassService,
+  type ContractStore,
+  ContractSyncService,
+  type NoteStore,
+} from '@aztec/pxe/server';
+import { TxResolverService } 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';
@@ -29,7 +35,8 @@ export class TXEStateMachine {
     public archiver: TXEArchiver,
     public anchorBlockStore: AnchorBlockStore,
     public contractSyncService: ContractSyncService,
-    public messageContextService: MessageContextService,
+    public contractClassService: ContractClassService,
+    public txResolver: TxResolverService,
   ) {}
 
   public static async create(
@@ -42,55 +49,63 @@ export class TXEStateMachine {
     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,
+    const node = new AztecNodeService({
+      config: aztecNodeConfig,
+      p2pClient: new DummyP2P(),
+      blockSource: archiver,
+      logsSource: archiver,
+      contractDataSource: archiver,
+      l1ToL2MessageSource: archiver,
+      worldStateSynchronizer: synchronizer,
+      sequencer: undefined,
+      proverNode: undefined,
+      slasherClient: undefined,
+      validatorsSentinel: undefined,
+      stopStartedWatchers: async () => {},
+      l1ChainId: CHAIN_ID,
+      version: VERSION,
+      globalVariableBuilder: new TXEGlobalVariablesBuilder(),
+      rollupContract: undefined,
+      feeProvider: new TXEFeeProvider(),
+      epochCache: new MockEpochCache(),
+      packageVersion: PACKAGE_VERSION,
+      peerProofVerifier: new TestCircuitVerifier(),
+      rpcProofVerifier: new TestCircuitVerifier(),
+      telemetry: undefined,
       log,
-    );
+    });
 
+    const contractClassService = new ContractClassService(node, contractStore);
     const contractSyncService = new ContractSyncService(
       node,
       contractStore,
+      contractClassService,
       noteStore,
       createLogger('txe:contract_sync'),
     );
 
-    const messageContextService = new MessageContextService(node);
+    const txResolver = new TxResolverService(node);
 
-    return new this(node, synchronizer, archiver, anchorBlockStore, contractSyncService, messageContextService);
+    return new this(
+      node,
+      synchronizer,
+      archiver,
+      anchorBlockStore,
+      contractSyncService,
+      contractClassService,
+      txResolver,
+    );
   }
 
   /** 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 };
-      },
+      getL2Tips: () => node.getChainTips(),
     };
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2Block, l1ToL2Messages: Fr[] = []) {
     // 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.
@@ -109,6 +124,7 @@ export class TXEStateMachine {
         feeRecipient: block.header.globalVariables.feeRecipient,
         gasFees: block.header.globalVariables.gasFees,
         totalManaUsed: block.header.totalManaUsed,
+        accumulatedFees: block.header.totalFees,
       }),
       [block],
       checkpointNumber,
@@ -127,7 +143,7 @@ export class TXEStateMachine {
     this.contractSyncService.wipe();
 
     await Promise.all([
-      this.synchronizer.handleL2Block(block),
+      this.synchronizer.handleL2Block(block, l1ToL2Messages),
       this.archiver.addCheckpoints([publishedCheckpoint], undefined),
       this.anchorBlockStore.setHeader(block.header),
     ]);

package/src/state_machine/mock_epoch_cache.ts

@@ -55,14 +55,6 @@ export class MockEpochCache implements EpochCacheInterface {
     return this.getEpochAndSlotInNextL1Slot();
   }
 
-  isProposerPipeliningEnabled(): boolean {
-    return false;
-  }
-
-  pipeliningOffset(): number {
-    return 0;
-  }
-
   getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
@@ -112,4 +104,8 @@ export class MockEpochCache implements EpochCacheInterface {
   getL1Constants(): L1RollupConstants {
     return EmptyL1RollupConstants;
   }
+
+  getLagInEpochsForValidatorSet(): number {
+    return 0;
+  }
 }

package/src/state_machine/synchronizer.ts

@@ -1,6 +1,8 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { AvmSimulatorPool } from '@aztec/simulator/server';
 import type { BlockHash, L2Block } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
@@ -15,18 +17,27 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   // This works when set to 1 as well.
   private blockNumber = BlockNumber.ZERO;
 
+  /** AVM execution backend (simulator pool + CDB server) shared across all public simulations. */
+  public avmSimulator!: AvmSimulatorPool;
+
   constructor(public nativeWorldStateService: NativeWorldStateService) {}
 
   static async create() {
     const nativeWorldStateService = await NativeWorldStateService.ephemeral();
 
-    return new this(nativeWorldStateService);
+    const synchronizer = new this(nativeWorldStateService);
+
+    synchronizer.avmSimulator = await AvmSimulatorPool.spawn({
+      wsdbIpcPath: nativeWorldStateService.getIpcPath(),
+    });
+
+    return synchronizer;
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2Block, l1ToL2Messages: Fr[] = []) {
     await this.nativeWorldStateService.handleL2BlockAndMessages(
       block,
-      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
+      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
     );
 
     this.blockNumber = block.header.globalVariables.blockNumber;
@@ -57,6 +68,11 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return this.nativeWorldStateService.getSnapshot(BlockNumber(blockNumber));
   }
 
+  /** Gets a snapshot at the given block number. The TXE has no reorgs, so the fork hash is not verified. */
+  public getVerifiedSnapshot(blockNumber: number, _blockHash: BlockHash): Promise<MerkleTreeReadOperations> {
+    return Promise.resolve(this.getSnapshot(blockNumber));
+  }
+
   /** Backups the db to the target path. */
   public backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>> {
     return this.nativeWorldStateService.backupTo(dstPath, compact);
@@ -70,8 +86,8 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     throw new Error('TXE Synchronizer does not implement "status"');
   }
 
-  public stop(): Promise<void> {
-    throw new Error('TXE Synchronizer does not implement "stop"');
+  public async stop(): Promise<void> {
+    await this.closeIpc();
   }
 
   public stopSync(): Promise<void> {
@@ -85,4 +101,9 @@ export class TXESynchronizer implements WorldStateSynchronizer {
   public clear(): Promise<void> {
     throw new Error('TXE Synchronizer does not implement "clear"');
   }
+
+  /** Clean up IPC resources. */
+  public async closeIpc(): Promise<void> {
+    await this.avmSimulator?.[Symbol.asyncDispose]();
+  }
 }