@aztec/txe 0.0.1-commit.9b94fc1 → 0.0.1-commit.c7c42ec

package/src/state_machine/archiver.ts

@@ -1,11 +1,22 @@
-import { ArchiverStoreHelper, KVArchiverDataStore, type PublishedL2Block } from '@aztec/archiver';
+import { ArchiverStoreHelper, KVArchiverDataStore } from '@aztec/archiver';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+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 { Fr } from '@aztec/foundation/fields';
+import { isDefined } from '@aztec/foundation/types';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block, L2BlockSource, L2Tips, ValidateBlockResult } from '@aztec/stdlib/block';
+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';
@@ -19,11 +30,28 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
     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),
-    ]);
+  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);
   }
@@ -32,16 +60,16 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    * 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();
+  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 getProvenBlockNumber(): Promise<number> {
-    return this.store.getSynchedL2BlockNumber();
+  public override getProvenBlockNumber(): Promise<BlockNumber> {
+    return this.store.getProvenBlockNumber();
   }
 
   /**
@@ -49,16 +77,55 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public override async getPublishedBlock(number: number): Promise<PublishedL2Block | undefined> {
+  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.getSynchedL2BlockNumber();
+      number = await this.store.getLatestBlockNumber();
     }
     if (number == 0) {
       return undefined;
     }
-    const blocks = await this.store.getPublishedBlocks(number, 1);
-    return blocks.length === 0 ? undefined : blocks[0];
+    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;
   }
 
   /**
@@ -66,8 +133,20 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public getBlock(number: number | 'latest'): Promise<L2Block | undefined> {
-    return this.getPublishedBlock(number != 'latest' ? number : -1).then(block => block?.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);
   }
 
   /**
@@ -77,17 +156,25 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
    */
   public async getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
     if (number === 'latest') {
-      number = await this.store.getSynchedL2BlockNumber();
+      number = await this.store.getLatestBlockNumber();
     }
     if (number === 0) {
       return undefined;
     }
-    const headers = await this.store.getBlockHeaders(number, 1);
+    const headers = await this.store.getBlockHeaders(BlockNumber(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 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> {
@@ -98,6 +185,10 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
     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"');
   }
@@ -110,8 +201,21 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
     throw new Error('TXE Archiver does not implement "isEpochComplete"');
   }
 
-  public getL2Tips(): Promise<L2Tips> {
-    throw new Error('TXE Archiver does not implement "getL2Tips"');
+  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> {
@@ -149,4 +253,11 @@ export class TXEArchiver extends ArchiverStoreHelper implements L2BlockSource {
   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

@@ -79,7 +79,9 @@ export class DummyP2P implements P2P {
   }
 
   public getTxStatus(_txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
-    throw new Error('DummyP2P does not implement "getTxStatus"');
+    // 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> {

package/src/state_machine/global_variable_builder.ts

@@ -1,9 +1,9 @@
-import type { SlotNumber } from '@aztec/foundation/branded-types';
+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 GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
+import { type CheckpointGlobalVariables, type GlobalVariableBuilder, GlobalVariables } from '@aztec/stdlib/tx';
 
 export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
   public getCurrentBaseFees(): Promise<GasFees> {
@@ -11,11 +11,28 @@ export class TXEGlobalVariablesBuilder implements GlobalVariableBuilder {
   }
 
   public buildGlobalVariables(
-    _blockNumber: number,
+    _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

@@ -2,8 +2,9 @@ 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, PublishedL2Block } from '@aztec/stdlib/block';
+import { AnchorBlockStore } 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';
 
@@ -21,13 +22,13 @@ export class TXEStateMachine {
     public node: AztecNode,
     public synchronizer: TXESynchronizer,
     public archiver: TXEArchiver,
-    public syncDataProvider: SyncDataProvider,
+    public anchorBlockStore: AnchorBlockStore,
   ) {}
 
   public static async create(db: AztecAsyncKVStore) {
     const archiver = new TXEArchiver(db);
     const synchronizer = await TXESynchronizer.create();
-    const syncDataProvider = new SyncDataProvider(db);
+    const anchorBlockStore = new AnchorBlockStore(db);
 
     const aztecNodeConfig = {} as AztecNodeConfig;
 
@@ -54,24 +55,24 @@ export class TXEStateMachine {
       log,
     );
 
-    return new this(node, synchronizer, archiver, syncDataProvider);
+    return new this(node, synchronizer, archiver, anchorBlockStore);
   }
 
   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),
-      this.archiver.addBlocks([
-        PublishedL2Block.fromFields({
-          block,
-          l1: {
-            blockHash: block.header.globalVariables.blockNumber.toString(),
-            blockNumber: BigInt(block.header.globalVariables.blockNumber),
-            timestamp: block.header.globalVariables.timestamp,
-          },
-          attestations: [],
-        }),
-      ]),
-      this.syncDataProvider.setHeader(block.getBlockHeader()),
+      this.synchronizer.handleL2Block(block.toL2Block()),
+      this.archiver.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockStore.setHeader(block.getBlockHeader()),
     ]);
   }
 }

package/src/state_machine/synchronizer.ts

@@ -1,6 +1,7 @@
 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 { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
   MerkleTreeWriteOperations,
@@ -12,7 +13,7 @@ import { NativeWorldStateService } from '@aztec/world-state/native';
 
 export class TXESynchronizer implements WorldStateSynchronizer {
   // This works when set to 1 as well.
-  private blockNumber = 0;
+  private blockNumber = BlockNumber.ZERO;
 
   constructor(public nativeWorldStateService: NativeWorldStateService) {}
 
@@ -22,7 +23,7 @@ export class TXESynchronizer implements WorldStateSynchronizer {
     return new this(nativeWorldStateService);
   }
 
-  public async handleL2Block(block: L2Block) {
+  public async handleL2Block(block: L2BlockNew) {
     await this.nativeWorldStateService.handleL2BlockAndMessages(
       block,
       Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.zero),
@@ -37,7 +38,7 @@ export class TXESynchronizer implements WorldStateSynchronizer {
    * @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> {
+  public syncImmediate(_minBlockNumber?: BlockNumber, _skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber> {
     return Promise.resolve(this.blockNumber);
   }
 
@@ -48,12 +49,12 @@ export class TXESynchronizer implements WorldStateSynchronizer {
 
   /** 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);
+    return this.nativeWorldStateService.fork(block ? BlockNumber(block) : undefined);
   }
 
   /** 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);
+    return this.nativeWorldStateService.getSnapshot(BlockNumber(blockNumber));
   }
 
   /** Backups the db to the target path. */