@aztec/txe 0.86.0 → 0.87.0

package/src/state_machine/archiver.ts

@@ -0,0 +1,132 @@
+import { ArchiverStoreHelper, KVArchiverDataStore, type PublishedL2Block } from '@aztec/archiver';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { L2Block, L2Tips } from '@aztec/stdlib/block';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { 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 {
+  constructor(db: AztecAsyncKVStore) {
+    super(new KVArchiverDataStore(db, 9999));
+  }
+
+  public override async addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
+    const opResults = await Promise.all([
+      this.store.addLogs(blocks.map(block => block.block)),
+      this.store.addBlocks(blocks),
+    ]);
+
+    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<number> {
+    return this.store.getSynchedL2BlockNumber();
+  }
+
+  /**
+   * 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 getProvenBlockNumber(): Promise<number> {
+    return this.store.getSynchedL2BlockNumber();
+  }
+
+  /**
+   * 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 override 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.getSynchedL2BlockNumber();
+    }
+    if (number == 0) {
+      return undefined;
+    }
+    const blocks = await this.store.getPublishedBlocks(number, 1);
+    return blocks.length === 0 ? undefined : blocks[0];
+  }
+
+  /**
+   * 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 getBlock(number: number): Promise<L2Block | undefined> {
+    return this.getPublishedBlock(number).then(block => block?.block);
+  }
+
+  /**
+   * 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.getSynchedL2BlockNumber();
+    }
+    if (number === 0) {
+      return undefined;
+    }
+    const headers = await this.store.getBlockHeaders(number, 1);
+    return headers.length === 0 ? undefined : headers[0];
+  }
+
+  public getBlocks(from: number, limit: number, _proven?: boolean): Promise<L2Block[]> {
+    return this.getPublishedBlocks(from, limit).then(blocks => blocks.map(b => b.block));
+  }
+
+  public getL2SlotNumber(): Promise<bigint> {
+    throw new Error('TXE Archiver does not implement "getL2SlotNumber"');
+  }
+
+  public getL2EpochNumber(): Promise<bigint> {
+    throw new Error('TXE Archiver does not implement "getL2EpochNumber"');
+  }
+
+  public getBlocksForEpoch(_epochNumber: bigint): Promise<L2Block[]> {
+    throw new Error('TXE Archiver does not implement "getBlocksForEpoch"');
+  }
+
+  public getBlockHeadersForEpoch(_epochNumber: bigint): Promise<BlockHeader[]> {
+    throw new Error('TXE Archiver does not implement "getBlockHeadersForEpoch"');
+  }
+
+  public isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+    throw new Error('TXE Archiver does not implement "isEpochComplete"');
+  }
+
+  public getL2Tips(): Promise<L2Tips> {
+    throw new Error('TXE Archiver does not implement "getL2Tips"');
+  }
+
+  public getL1Constants(): Promise<L1RollupConstants> {
+    throw new Error('TXE Archiver does not implement "getL2Constants"');
+  }
+
+  public syncImmediate(): Promise<void> {
+    throw new Error('TXE Archiver does not implement "syncImmediate"');
+  }
+
+  public getContract(_address: AztecAddress, _blockNumber?: number): 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"');
+  }
+}

package/src/state_machine/dummy_p2p_client.ts

@@ -0,0 +1,167 @@
+import type { ENR, P2P, P2PConfig, P2PSyncState } from '@aztec/p2p';
+import type { 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 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: (block: BlockProposal) => Promise<BlockAttestation | undefined>): 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> {
+    throw new Error('DummyP2P does not implement "getTxStatus"');
+  }
+
+  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: bigint, _proposalId?: string): Promise<BlockAttestation[]> {
+    throw new Error('DummyP2P does not implement "getAttestationForSlot"');
+  }
+
+  public addAttestation(_attestation: BlockAttestation): Promise<void> {
+    throw new Error('DummyP2P does not implement "addAttestation"');
+  }
+
+  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 | undefined)[]> {
+    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 addTxs(_txs: Tx[]): Promise<void> {
+    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".');
+  }
+}

package/src/state_machine/global_variable_builder.ts

@@ -0,0 +1,55 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import { type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
+
+export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
+  private timestamp = new Fr(1);
+  private slotNumber = 1n;
+
+  // The version and chainId should match the one on txe_oracle
+  private version = new Fr(1);
+  private chainId = new Fr(1);
+
+  constructor() {}
+
+  public getCurrentBaseFees(): Promise<GasFees> {
+    return Promise.resolve(new GasFees(Fr.ZERO, Fr.ZERO));
+  }
+
+  /**
+   * Simple builder of global variables that use the minimum time possible.
+   * @param blockNumber - The block number to build global variables for.
+   * @param coinbase - The address to receive block reward.
+   * @param feeRecipient - The address to receive fees.
+   * @param slotNumber - The slot number to use for the global variables, if undefined it will be calculated.
+   * @returns The global variables for the given block number.
+   */
+  public buildGlobalVariables(
+    blockNumber: Fr,
+    coinbase: EthAddress,
+    feeRecipient: AztecAddress,
+    slotNumber?: bigint,
+  ): Promise<GlobalVariables> {
+    const gasFees = new GasFees(Fr.ZERO, Fr.ZERO);
+
+    slotNumber ??= this.slotNumber;
+
+    const globalVariables = new GlobalVariables(
+      this.chainId,
+      this.version,
+      blockNumber,
+      Fr.fromString(slotNumber.toString()),
+      this.timestamp,
+      coinbase,
+      feeRecipient,
+      gasFees,
+    );
+
+    this.slotNumber++;
+    this.timestamp = this.timestamp.add(new Fr(1));
+
+    return Promise.resolve(globalVariables);
+  }
+}

package/src/state_machine/index.ts

@@ -0,0 +1,71 @@
+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 { SyncDataProvider } from '@aztec/pxe/server';
+import type { L2Block } from '@aztec/stdlib/block';
+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 { TXESynchronizer } from './synchronizer.js';
+
+export class TXEStateMachine {
+  constructor(
+    public node: AztecNode,
+    public synchronizer: TXESynchronizer,
+    public archiver: TXEArchiver,
+    public syncDataProvider: SyncDataProvider,
+  ) {}
+
+  public static async create(db: AztecAsyncKVStore) {
+    const archiver = new TXEArchiver(db);
+    const synchronizer = await TXESynchronizer.create();
+    const syncDataProvider = new SyncDataProvider(db);
+
+    const aztecNodeConfig = {} as AztecNodeConfig;
+
+    const log = createLogger('txe_node');
+    const node = new AztecNodeService(
+      aztecNodeConfig,
+      new DummyP2P(),
+      archiver,
+      archiver,
+      archiver,
+      archiver,
+      synchronizer,
+      undefined,
+      undefined,
+      // version and chainId should match the ones in txe oracle
+      1,
+      1,
+      new TXEGlobalVariablesBuilder(),
+      getPackageVersion() ?? '',
+      new TestCircuitVerifier(),
+      undefined,
+      log,
+    );
+
+    return new this(node, synchronizer, archiver, syncDataProvider);
+  }
+
+  public async handleL2Block(block: L2Block) {
+    await Promise.all([
+      this.synchronizer.handleL2Block(block),
+      this.archiver.addBlocks([
+        {
+          block,
+          l1: {
+            blockHash: block.header.globalVariables.blockNumber.toNumber().toString(),
+            blockNumber: block.header.globalVariables.blockNumber.toBigInt(),
+            timestamp: block.header.globalVariables.blockNumber.toBigInt(),
+          },
+          signatures: [],
+        },
+      ]),
+      this.syncDataProvider.setHeader(block.header),
+    ]);
+  }
+}

package/src/state_machine/synchronizer.ts

@@ -0,0 +1,87 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import type { L2Block } from '@aztec/stdlib/block';
+import type {
+  MerkleTreeReadOperations,
+  MerkleTreeWriteOperations,
+  SnapshotDataKeys,
+  WorldStateSynchronizer,
+  WorldStateSynchronizerStatus,
+} from '@aztec/stdlib/interfaces/server';
+import { NativeWorldStateService } from '@aztec/world-state/native';
+
+export class TXESynchronizer implements WorldStateSynchronizer {
+  // This works when set to 1 as well.
+  private blockNumber = 0;
+
+  constructor(public nativeWorldStateService: NativeWorldStateService) {}
+
+  static async create() {
+    const nativeWorldStateService = await NativeWorldStateService.tmp();
+
+    return new this(nativeWorldStateService);
+  }
+
+  public async handleL2Block(block: L2Block) {
+    await this.nativeWorldStateService.handleL2BlockAndMessages(
+      block,
+      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
+    );
+
+    this.blockNumber = block.header.globalVariables.blockNumber.toNumber();
+  }
+
+  /**
+   * 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.
+   * @returns A promise that resolves with the block number the world state was synced to
+   */
+  public syncImmediate(_minBlockNumber?: number, _skipThrowIfTargetNotReached?: boolean): Promise<number> {
+    return Promise.resolve(this.blockNumber);
+  }
+
+  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
+  public getCommitted(): MerkleTreeReadOperations {
+    return this.nativeWorldStateService.getCommitted();
+  }
+
+  /** Forks the world state at the given block number, defaulting to the latest one. */
+  public fork(block?: number): Promise<MerkleTreeWriteOperations> {
+    return this.nativeWorldStateService.fork(block);
+  }
+
+  /** Gets a handle that allows reading the state as it was at the given block number. */
+  public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
+    return this.nativeWorldStateService.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);
+  }
+
+  public start(): Promise<void> {
+    throw new Error('TXE Synchronizer does not implement "start"');
+  }
+
+  public status(): Promise<WorldStateSynchronizerStatus> {
+    throw new Error('TXE Synchronizer does not implement "status"');
+  }
+
+  public stop(): Promise<void> {
+    throw new Error('TXE Synchronizer does not implement "stop"');
+  }
+
+  public stopSync(): Promise<void> {
+    throw new Error('TXE Synchronizer does not implement "stopSync"');
+  }
+
+  public resumeSync(): void {
+    throw new Error('TXE Synchronizer does not implement "resumeSync"');
+  }
+
+  public clear(): Promise<void> {
+    throw new Error('TXE Synchronizer does not implement "clear"');
+  }
+}