@aztec/ethereum 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/publisher_manager.ts

@@ -1,5 +1,5 @@
 import { pick } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 
 import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
@@ -28,13 +28,15 @@ const busyStates: TxUtilsState[] = [
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-  private log = createLogger('publisher:manager');
+  private log: Logger;
   private config: { publisherAllowInvalidStates?: boolean };
 
   constructor(
     private publishers: UtilsType[],
     config: { publisherAllowInvalidStates?: boolean },
+    bindings?: LoggerBindings,
   ) {
+    this.log = createLogger('publisher:manager', bindings);
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
     this.config = pick(config, 'publisherAllowInvalidStates');

package/src/queries.ts

@@ -1,8 +1,9 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L1ContractsConfig } from './config.js';
+import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
 import { GovernanceProposerContract } from './contracts/governance_proposer.js';
+import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { ViemPublicClient } from './types.js';
 
@@ -25,6 +26,8 @@ export async function getL1ContractsConfig(
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
   const slasher = await rollup.getSlasherContract();
+  const rollupAddresses = await rollup.getRollupAddresses();
+  const inboxContract = new InboxContract(publicClient, rollupAddresses.inboxAddress.toString());
 
   const [
     l1StartBlock,
@@ -33,7 +36,9 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
-    lagInEpochs,
+    lagInEpochsForValidatorSet,
+    lagInEpochsForRandao,
+    inboxLag,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
@@ -59,7 +64,9 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
-    rollup.getLagInEpochs(),
+    rollup.getLagInEpochsForValidatorSet(),
+    rollup.getLagInEpochsForRandao(),
+    inboxContract.getLag(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
     rollup.getLocalEjectionThreshold(),
@@ -87,14 +94,17 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
-    lagInEpochs: Number(lagInEpochs),
+    lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: Number(lagInEpochsForRandao),
+    inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
     activationThreshold,
     ejectionThreshold,
     localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
-    slashingRoundSizeInEpochs: Number(slashingRoundSize / aztecEpochDuration),
+    slashingRoundSizeInEpochs: Number(Number(slashingRoundSize) / aztecEpochDuration),
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
     slashingVetoer,
@@ -102,12 +112,13 @@ export async function getL1ContractsConfig(
     manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
-    genesisArchiveTreeRoot,
+    genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
     exitDelaySeconds: Number(exitDelay),
     slasherFlavor: slasherProposer?.type ?? 'tally',
     slashingOffsetInRounds: Number(slashingOffsetInRounds),
     slashAmountSmall: slashingAmounts[0],
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }

package/src/test/chain_monitor.ts

@@ -1,4 +1,6 @@
-import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { InboxContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
@@ -10,11 +12,13 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
-  'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  checkpoint: [
+    { checkpointNumber: CheckpointNumber; l1BlockNumber: number; l2SlotNumber: SlotNumber; timestamp: bigint },
+  ];
+  'checkpoint-proven': [{ provenCheckpointNumber: CheckpointNumber; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
-  'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
-  'l2-slot': [{ l2SlotNumber: number; timestamp: bigint }];
+  'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
 };
 
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
@@ -27,20 +31,20 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
   /** Current L1 block number */
   public l1BlockNumber!: number;
-  /** Current L2 block number */
-  public l2BlockNumber!: number;
-  /** Current L2 proven block number */
-  public l2ProvenBlockNumber!: number;
-  /** L1 timestamp for the current L2 block */
-  public l2BlockTimestamp!: bigint;
-  /** L1 timestamp for the proven L2 block */
-  public l2ProvenBlockTimestamp!: bigint;
+  /** Current checkpoint number */
+  public checkpointNumber!: CheckpointNumber;
+  /** Current proven checkpoint number */
+  public provenCheckpointNumber!: CheckpointNumber;
+  /** L1 timestamp for the current checkpoint */
+  public checkpointTimestamp!: bigint;
+  /** L1 timestamp for the proven checkpoint */
+  public provenCheckpointTimestamp!: bigint;
   /** Total number of L2 messages pushed into the Inbox */
   public totalL2Messages: number = 0;
   /** Current L2 epoch number */
-  public l2EpochNumber!: bigint;
+  public l2EpochNumber!: EpochNumber;
   /** Current L2 slot number */
-  public l2SlotNumber!: bigint;
+  public l2SlotNumber!: SlotNumber;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -114,28 +118,28 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
     let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
 
-    const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
-    if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2BlockNumber));
-      msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
-      this.l2BlockNumber = newL2BlockNumber;
-      this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', {
-        l2BlockNumber: newL2BlockNumber,
+    const newCheckpointNumber = await this.rollup.getCheckpointNumber();
+    if (this.checkpointNumber !== newCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newCheckpointNumber);
+      msg += ` with new checkpoint ${newCheckpointNumber} for epoch ${epochNumber}`;
+      this.checkpointNumber = newCheckpointNumber;
+      this.checkpointTimestamp = timestamp;
+      this.emit('checkpoint', {
+        checkpointNumber: newCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
-        l2SlotNumber: Number(l2SlotNumber),
+        l2SlotNumber,
         timestamp,
       });
     }
 
-    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-    if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2ProvenBlockNumber));
-      msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
-      this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
-      this.l2ProvenBlockTimestamp = timestamp;
-      this.emit('l2-block-proven', {
-        l2ProvenBlockNumber: newL2ProvenBlockNumber,
+    const newProvenCheckpointNumber = await this.rollup.getProvenCheckpointNumber();
+    if (this.provenCheckpointNumber !== newProvenCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newProvenCheckpointNumber);
+      msg += ` with proof up to checkpoint ${newProvenCheckpointNumber} for epoch ${epochNumber}`;
+      this.provenCheckpointNumber = newProvenCheckpointNumber;
+      this.provenCheckpointTimestamp = timestamp;
+      this.emit('checkpoint-proven', {
+        provenCheckpointNumber: newProvenCheckpointNumber,
         l1BlockNumber: newL1BlockNumber,
         timestamp,
       });
@@ -152,14 +156,14 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     let committee: EthAddress[] | undefined;
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
-      committee = (await this.rollup.getCurrentEpochCommittee())?.map(addr => EthAddress.fromString(addr));
-      this.emit('l2-epoch', { l2EpochNumber: Number(l2Epoch), timestamp, committee });
+      committee = await this.rollup.getCurrentEpochCommittee();
+      this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
       msg += ` starting new epoch ${this.l2EpochNumber} `;
     }
 
     if (l2SlotNumber !== this.l2SlotNumber) {
       this.l2SlotNumber = l2SlotNumber;
-      this.emit('l2-slot', { l2SlotNumber: Number(l2SlotNumber), timestamp });
+      this.emit('l2-slot', { l2SlotNumber, timestamp });
     }
 
     this.logger.info(msg, {
@@ -168,8 +172,8 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       l1BlockNumber: this.l1BlockNumber,
       l2SlotNumber,
       l2Epoch,
-      l2BlockNumber: this.l2BlockNumber,
-      l2ProvenBlockNumber: this.l2ProvenBlockNumber,
+      checkpointNumber: this.checkpointNumber,
+      provenCheckpointNumber: this.provenCheckpointNumber,
       totalL2Messages: this.totalL2Messages,
       committee,
     });
@@ -177,14 +181,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     return this;
   }
 
-  public waitUntilL2Slot(slot: number | bigint): Promise<void> {
-    const targetSlot = typeof slot === 'bigint' ? slot.valueOf() : slot;
-    if (this.l2SlotNumber >= targetSlot) {
+  public waitUntilL2Slot(slot: SlotNumber): Promise<void> {
+    if (this.l2SlotNumber >= slot) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2SlotNumber: number; timestamp: bigint }) => {
-        if (data.l2SlotNumber >= targetSlot) {
+      const listener = (data: { l2SlotNumber: SlotNumber; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= slot) {
           this.off('l2-slot', listener);
           resolve();
         }
@@ -225,19 +228,18 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     });
   }
 
-  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
-    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
-    if (this.l2BlockNumber >= targetBlock) {
+  public waitUntilCheckpoint(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.checkpointNumber >= checkpointNumber) {
       return Promise.resolve();
     }
     return new Promise(resolve => {
-      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
-        if (data.l2BlockNumber >= targetBlock) {
-          this.off('l2-block', listener);
+      const listener = (data: { checkpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.checkpointNumber >= checkpointNumber) {
+          this.off('checkpoint', listener);
           resolve();
         }
       };
-      this.on('l2-block', listener);
+      this.on('checkpoint', listener);
     });
   }
 }

package/src/test/eth_cheat_codes.ts

@@ -1,12 +1,13 @@
 import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 import { pluralize } from '@aztec/foundation/string';
-import type { TestDateProvider } from '@aztec/foundation/timer';
+import type { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 
-import { type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { type Chain, type Hex, type Transaction, createPublicClient, fallback, hexToNumber, http } from 'viem';
+import { foundry } from 'viem/chains';
 
 import type { ViemPublicClient } from '../types.js';
 
@@ -20,13 +21,22 @@ export class EthCheatCodes {
      * The RPC URL to use for interacting with the chain
      */
     public rpcUrls: string[],
+    /**
+     * The date provider to use for time operations
+     */
+    public dateProvider: DateProvider | TestDateProvider,
     /**
      * The logger to use for the eth cheatcodes
      */
     public logger = createLogger('ethereum:cheat_codes'),
+    /**
+     * The chain configuration provided to Anvil
+     */
+    public chain: Chain = foundry,
   ) {
     this.publicClient = createPublicClient({
-      transport: fallback(this.rpcUrls.map(url => http(url))),
+      transport: fallback(this.rpcUrls.map(url => http(url, { batch: false }))),
+      chain: chain,
     });
   }
 
@@ -230,12 +240,12 @@ export class EthCheatCodes {
   /**
    * Set the next block timestamp and mines the block.
    * Optionally resets interval mining so the next block is mined in `blockInterval` seconds from now.
-   * Optionally updates a provided date provider to follow L1 time.
+   * Always updates the injected date provider to follow L1 time.
    * @param timestamp - The timestamp to set the next block to
    */
   public async warp(
     timestamp: number | bigint,
-    opts: { silent?: boolean; resetBlockInterval?: boolean; updateDateProvider?: TestDateProvider } = {},
+    opts: { silent?: boolean; resetBlockInterval?: boolean } = {},
   ): Promise<void> {
     let blockInterval: number | null = null;
     try {
@@ -250,8 +260,10 @@ export class EthCheatCodes {
       await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
       // And mine a block so the timestamp goes into effect now
       await this.doMine();
-      // Update the date provider if provided so it follows L1 time
-      opts.updateDateProvider?.setTime(Number(timestamp) * 1000);
+      // Update the injected date provider so it follows L1 time
+      if ('setTime' in this.dateProvider) {
+        this.dateProvider.setTime(Number(timestamp) * 1000);
+      }
     } catch (err) {
       throw new Error(`Error warping: ${err}`);
     } finally {
@@ -282,14 +294,21 @@ export class EthCheatCodes {
    * @param slot - The storage slot
    * @param value - The value to set the storage slot to
    */
-  public async store(contract: EthAddress, slot: bigint, value: bigint): Promise<void> {
+  public async store(
+    contract: EthAddress,
+    slot: bigint,
+    value: bigint,
+    opts: { silent?: boolean } = {},
+  ): Promise<void> {
     // for the rpc call, we need to change value to be a 32 byte hex string.
     try {
       await this.rpcCall('hardhat_setStorageAt', [contract.toString(), toHex(slot), toHex(value, true)]);
     } catch (err) {
       throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${err}`);
     }
-    this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
+    if (!opts.silent) {
+      this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
+    }
   }
 
   /**
@@ -499,7 +518,7 @@ export class EthCheatCodes {
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);
   }
 
-  public async execWithPausedAnvil(fn: () => Promise<void>): Promise<void> {
+  public async execWithPausedAnvil<T>(fn: () => Promise<T>): Promise<T> {
     const [blockInterval, wasAutoMining] = await Promise.all([this.getIntervalMining(), this.isAutoMining()]);
     try {
       if (blockInterval !== null) {
@@ -510,7 +529,7 @@ export class EthCheatCodes {
         await this.setAutomine(false, { silent: true });
       }
 
-      await fn();
+      return await fn();
     } finally {
       try {
         // restore automine if necessary
@@ -532,10 +551,10 @@ export class EthCheatCodes {
     }
   }
 
-  public async syncDateProvider(dateProvider: TestDateProvider) {
+  public async syncDateProvider() {
     const timestamp = await this.timestamp();
-    if ('setTime' in dateProvider) {
-      dateProvider.setTime(timestamp * 1000);
+    if ('setTime' in this.dateProvider) {
+      this.dateProvider.setTime(timestamp * 1000);
     }
   }
 }

package/src/test/index.ts

@@ -1,8 +1,6 @@
-export * from './delayed_tx_utils.js';
 export * from './eth_cheat_codes.js';
 export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';
-export * from './tx_delayer.js';
 export * from './upgrade_utils.js';
 export * from './chain_monitor.js';
 export * from './rollup_cheat_codes.js';