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

package/src/state_machine/dummy_p2p_client.ts

@@ -4,6 +4,7 @@ import type {
   ENR,
   P2P,
   P2PBlockReceivedCallback,
+  P2PCheckpointReceivedCallback,
   P2PConfig,
   P2PSyncState,
   PeerId,
@@ -14,14 +15,10 @@ import type {
 } 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 { BlockProposal, CheckpointAttestation, CheckpointProposal } from '@aztec/stdlib/p2p';
 import type { 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> {
     return Promise.resolve();
   }
@@ -46,10 +43,22 @@ export class DummyP2P implements P2P {
     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 registerCheckpointProposalHandler(_handler: P2PCheckpointReceivedCallback): void {
+    throw new Error('DummyP2P does not implement "registerCheckpointProposalHandler"');
+  }
+
   public requestTxs(_txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
     throw new Error('DummyP2P does not implement "requestTxs"');
   }
@@ -79,7 +88,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> {
@@ -118,16 +129,12 @@ export class DummyP2P implements P2P {
     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 deleteAttestation(_attestation: BlockAttestation): Promise<void> {
-    return Promise.resolve();
+  public getCheckpointAttestationsForSlot(_slot: SlotNumber, _proposalId?: string): Promise<CheckpointAttestation[]> {
+    throw new Error('DummyP2P does not implement "getCheckpointAttestationsForSlot"');
   }
 
-  public addAttestations(_attestations: BlockAttestation[]): Promise<void> {
-    throw new Error('DummyP2P does not implement "addAttestations"');
+  public addCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {
+    throw new Error('DummyP2P does not implement "addCheckpointAttestations"');
   }
 
   public getL2BlockHash(_number: number): Promise<string | undefined> {

package/src/state_machine/global_variable_builder.ts

@@ -1,21 +1,38 @@
-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> {
+  public getCurrentMinFees(): Promise<GasFees> {
     return Promise.resolve(new GasFees(0, 0));
   }
 
   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

@@ -1,10 +1,14 @@
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
 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 { 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 { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { getPackageVersion } from '@aztec/stdlib/update-checker';
 
 import { TXEArchiver } from './archiver.js';
@@ -21,13 +25,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 +58,43 @@ export class TXEStateMachine {
       log,
     );
 
-    return new this(node, synchronizer, archiver, syncDataProvider);
+    return new this(node, synchronizer, archiver, anchorBlockStore);
   }
 
   public async handleL2Block(block: L2Block) {
+    // Create a checkpoint from the block manually
+    const checkpoint = new Checkpoint(
+      block.archive,
+      CheckpointHeader.from({
+        lastArchiveRoot: block.header.lastArchive.root,
+        inHash: Fr.ZERO,
+        blobsHash: Fr.ZERO,
+        blockHeadersHash: Fr.ZERO,
+        epochOutHash: Fr.ZERO,
+        slotNumber: block.header.globalVariables.slotNumber,
+        timestamp: block.header.globalVariables.timestamp,
+        coinbase: block.header.globalVariables.coinbase,
+        feeRecipient: block.header.globalVariables.feeRecipient,
+        gasFees: block.header.globalVariables.gasFees,
+        totalManaUsed: block.header.totalManaUsed,
+      }),
+      [block],
+      CheckpointNumber.fromBlockNumber(block.number),
+    );
+
+    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.archiver.addCheckpoints([publishedCheckpoint], undefined),
+      this.anchorBlockStore.setHeader(block.header),
     ]);
   }
 }

package/src/state_machine/mock_epoch_cache.ts

@@ -12,14 +12,16 @@ export class MockEpochCache implements EpochCacheInterface {
       committee: undefined,
       seed: 0n,
       epoch: EpochNumber.ZERO,
+      isEscapeHatchOpen: false,
     });
   }
 
-  getEpochAndSlotNow(): EpochAndSlot {
+  getEpochAndSlotNow(): EpochAndSlot & { nowMs: bigint } {
     return {
       epoch: EpochNumber.ZERO,
       slot: SlotNumber(0),
       ts: 0n,
+      nowMs: 0n,
     };
   }
 
@@ -40,18 +42,15 @@ export class MockEpochCache implements EpochCacheInterface {
     return 0n;
   }
 
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: SlotNumber;
-    nextSlot: SlotNumber;
-  }> {
-    return Promise.resolve({
-      currentProposer: undefined,
-      nextProposer: undefined,
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
       currentSlot: SlotNumber(0),
       nextSlot: SlotNumber(0),
-    });
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(undefined);
   }
 
   isInCommittee(_slot: SlotTag, _validator: EthAddress): Promise<boolean> {

package/src/state_machine/synchronizer.ts

@@ -1,5 +1,6 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { L2Block } from '@aztec/stdlib/block';
 import type {
   MerkleTreeReadOperations,
@@ -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) {}
 
@@ -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. */