@aztec/txe 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/state_machine/mock_epoch_cache.ts

@@ -1,56 +1,88 @@
 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,
-      epoch: 0n,
+      epoch: EpochNumber.ZERO,
+      isEscapeHatchOpen: false,
     });
   }
 
-  getEpochAndSlotNow(): EpochAndSlot {
+  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: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
+      nowMs: 0n,
     };
   }
 
-  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { now: bigint } {
+  getEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
     return {
-      epoch: 0n,
-      slot: 0n,
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber(0),
       ts: 0n,
-      now: 0n,
+      nowSeconds: 0n,
     };
   }
 
-  getProposerIndexEncoding(_epoch: bigint, _slot: bigint, _seed: bigint): `0x${string}` {
+  getTargetEpochAndSlotInNextL1Slot(): EpochAndSlot & { nowSeconds: bigint } {
+    return this.getEpochAndSlotInNextL1Slot();
+  }
+
+  isProposerPipeliningEnabled(): boolean {
+    return false;
+  }
+
+  getProposerIndexEncoding(_epoch: EpochNumber, _slot: SlotNumber, _seed: bigint): `0x${string}` {
     return '0x00';
   }
 
-  computeProposerIndex(_slot: bigint, _epoch: bigint, _seed: bigint, _size: bigint): bigint {
+  computeProposerIndex(_slot: SlotNumber, _epoch: EpochNumber, _seed: bigint, _size: bigint): bigint {
     return 0n;
   }
 
-  getProposerAttesterAddressInCurrentOrNextSlot(): Promise<{
-    currentProposer: EthAddress | undefined;
-    nextProposer: EthAddress | undefined;
-    currentSlot: bigint;
-    nextSlot: bigint;
-  }> {
-    return Promise.resolve({
-      currentProposer: undefined,
-      nextProposer: undefined,
-      currentSlot: 0n,
-      nextSlot: 0n,
-    });
+  getCurrentAndNextSlot(): { currentSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      currentSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
+  getTargetAndNextSlot(): { targetSlot: SlotNumber; nextSlot: SlotNumber } {
+    return {
+      targetSlot: SlotNumber(0),
+      nextSlot: SlotNumber(0),
+    };
+  }
+
+  getProposerAttesterAddressInSlot(_slot: SlotNumber): Promise<EthAddress | undefined> {
+    return Promise.resolve(undefined);
   }
 
   isInCommittee(_slot: SlotTag, _validator: EthAddress): Promise<boolean> {
@@ -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,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 { BlockHash, L2Block } 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) {}
 
@@ -32,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?: number, _skipThrowIfTargetNotReached?: boolean): Promise<number> {
+  public syncImmediate(_minBlockNumber?: BlockNumber, _blockHash?: BlockHash): 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. */