@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.20251212

package/src/l1_tx_utils/types.ts

@@ -0,0 +1,85 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
+
+import type { Abi, Address, Hex, TransactionReceipt, TransactionSerializable } from 'viem';
+
+import type { L1TxUtilsConfig } from './config.js';
+
+export interface L1TxRequest {
+  to: Address | null;
+  data?: Hex;
+  value?: bigint;
+  abi?: Abi;
+}
+
+export type L1TxConfig = Partial<L1TxUtilsConfig> & { gasLimit?: bigint; txTimeoutAt?: Date };
+
+export interface L1BlobInputs {
+  blobs: Uint8Array[];
+  kzg: BlobKzgInstance;
+  maxFeePerBlobGas?: bigint;
+}
+
+export interface GasPrice {
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+  maxFeePerBlobGas?: bigint;
+}
+
+export type TransactionStats = {
+  /** Address of the sender. */
+  sender: string;
+  /** Hash of the transaction. */
+  transactionHash: string;
+  /** Size in bytes of the tx calldata */
+  calldataSize: number;
+  /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
+  calldataGas: number;
+};
+
+export enum TxUtilsState {
+  IDLE,
+  SENT,
+  SPEED_UP,
+  CANCELLED,
+  NOT_MINED,
+  MINED,
+}
+
+export const TerminalTxUtilsState = [TxUtilsState.IDLE, TxUtilsState.MINED, TxUtilsState.NOT_MINED];
+
+export type L1TxState = {
+  id: number;
+  txHashes: Hex[];
+  cancelTxHashes: Hex[];
+  gasLimit: bigint;
+  gasPrice: GasPrice;
+  txConfigOverrides: L1TxConfig;
+  request: L1TxRequest;
+  status: TxUtilsState;
+  nonce: number;
+  sentAtL1Ts: Date;
+  lastSentAtL1Ts: Date;
+  receipt?: TransactionReceipt;
+  blobInputs: L1BlobInputs | undefined;
+};
+
+export type SigningCallback = (
+  transaction: TransactionSerializable,
+  signingAddress: EthAddress,
+) => Promise<ViemTransactionSignature>;
+
+export class UnknownMinedTxError extends Error {
+  constructor(nonce: number, account: string) {
+    super(`Nonce ${nonce} from account ${account} is MINED but not by one of our expected transactions`);
+    this.name = 'UnknownMinedTxError';
+  }
+}
+
+export class DroppedTransactionError extends Error {
+  constructor(nonce: number, account: string) {
+    super(`Transaction with nonce ${nonce} from account ${account} was dropped from the mempool`);
+    this.name = 'DroppedTransactionError';
+  }
+}

package/src/l1_tx_utils/utils.ts

@@ -0,0 +1,16 @@
+import { compactArray } from '@aztec/foundation/collection';
+
+import type { ContractFunctionExecutionError } from 'viem';
+
+export function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError) {
+  return compactArray([err.shortMessage, ...(err.metaMessages ?? []).slice(0, 2).map(s => s.trim())]).join(' ');
+}
+
+/*
+ * Returns cost of calldata usage in Ethereum.
+ * @param data - Calldata.
+ * @returns 4 for each zero byte, 16 for each nonzero.
+ */
+export function getCalldataGasUsage(data: Uint8Array) {
+  return data.filter(byte => byte === 0).length * 4 + data.filter(byte => byte !== 0).length * 16;
+}

package/src/publisher_manager.ts

@@ -1,31 +1,73 @@
+import { pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 
-import { L1TxUtils, TxUtilsState } from './l1_tx_utils.js';
+import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
 
-const sortOrder = [TxUtilsState.IDLE, TxUtilsState.MINED];
-const invalidStates = [TxUtilsState.SENT, TxUtilsState.SPEED_UP, TxUtilsState.CANCELLED, TxUtilsState.NOT_MINED]; // Cancelled and not mined are states that can be handled by a later iteration
+// Defines the order in which we prioritise publishers based on their state (first is better)
+const sortOrder = [
+  // Always prefer sending from idle publishers
+  TxUtilsState.IDLE,
+  // Then from publishers that have sent a tx and it got mined
+  TxUtilsState.MINED,
+  // Then from publishers that have sent a tx but it's in-flight
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.SENT,
+  // We leave cancelled and not-mined states for last, since these represent failures to mines and could be problematic
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
+
+// Which states represent a busy publisher that we should avoid if possible
+const busyStates: TxUtilsState[] = [
+  TxUtilsState.SENT,
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
 
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 
 export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
-  private log = createLogger('PublisherManager');
+  private log = createLogger('publisher:manager');
+  private config: { publisherAllowInvalidStates?: boolean };
 
-  constructor(private publishers: UtilsType[]) {
+  constructor(
+    private publishers: UtilsType[],
+    config: { publisherAllowInvalidStates?: boolean },
+  ) {
     this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
     this.publishers = publishers;
+    this.config = pick(config, 'publisherAllowInvalidStates');
+  }
+
+  /** Loads the state of all publishers and resumes monitoring any pending txs */
+  public async loadState(): Promise<void> {
+    await Promise.all(this.publishers.map(pub => pub.loadStateAndResumeMonitoring()));
   }
 
   // Finds and prioritises available publishers based on
   // 1. Validity as per the provided filter function
   // 2. Validity based on the state the publisher is in
-  // 3. Priority based on state as defined bu sortOrder
+  // 3. Priority based on state as defined by sortOrder
   // 4. Then priority based on highest balance
   // 5. Then priority based on least recently used
   public async getAvailablePublisher(filter: PublisherFilter<UtilsType> = () => true): Promise<UtilsType> {
+    this.log.debug(`Getting available publisher`, {
+      publishers: this.publishers.map(p => ({
+        address: p.getSenderAddress(),
+        state: p.state,
+        lastMined: p.lastMinedAtBlockNumber,
+      })),
+    });
+
     // Extract the valid publishers
-    const validPublishers = this.publishers.filter(
-      (pub: UtilsType) => !invalidStates.includes(pub.state) && filter(pub),
-    );
+    let validPublishers = this.publishers.filter((pub: UtilsType) => !busyStates.includes(pub.state) && filter(pub));
+
+    // If none found but we allow invalid (busy) states, try again including them
+    if (validPublishers.length === 0 && this.config.publisherAllowInvalidStates) {
+      this.log.warn(`No valid publishers found. Trying again including invalid states.`);
+      validPublishers = this.publishers.filter(pub => filter(pub));
+    }
 
     // Error if none found
     if (validPublishers.length === 0) {

package/src/queries.ts

@@ -1,7 +1,4 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
-
-import { getContract } from 'viem';
 
 import type { L1ContractsConfig } from './config.js';
 import { ReadOnlyGovernanceContract } from './contracts/governance.js';
@@ -27,8 +24,7 @@ export async function getL1ContractsConfig(
   const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
-  const slasherAddress = await rollup.getSlasher();
-  const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: publicClient });
+  const slasher = await rollup.getSlasherContract();
 
   const [
     l1StartBlock,
@@ -37,8 +33,11 @@ export async function getL1ContractsConfig(
     aztecSlotDuration,
     aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
+    lagInEpochsForValidatorSet,
+    lagInEpochsForRandao,
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
@@ -48,6 +47,7 @@ export async function getL1ContractsConfig(
     slashingOffsetInRounds,
     slashingAmounts,
     slashingVetoer,
+    slashingDisableDuration,
     manaTarget,
     provingCostPerMana,
     rollupVersion,
@@ -60,8 +60,11 @@ export async function getL1ContractsConfig(
     rollup.getSlotDuration(),
     rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
+    rollup.getLagInEpochsForValidatorSet(),
+    rollup.getLagInEpochsForRandao(),
     rollup.getActivationThreshold(),
     rollup.getEjectionThreshold(),
+    rollup.getLocalEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
     slasherProposer?.getQuorumSize() ?? 0n,
@@ -70,7 +73,8 @@ export async function getL1ContractsConfig(
     slasherProposer?.getExecutionDelayInRounds() ?? 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
     slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
-    slasher.read.VETOER(),
+    slasher?.getVetoer() ?? EthAddress.ZERO,
+    slasher?.getSlashingDisableDuration() ?? 0,
     rollup.getManaTarget(),
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
@@ -85,16 +89,20 @@ export async function getL1ContractsConfig(
     aztecSlotDuration: Number(aztecSlotDuration),
     aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: Number(lagInEpochsForRandao),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
     activationThreshold,
     ejectionThreshold,
+    localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
     slashingRoundSizeInEpochs: Number(slashingRoundSize / aztecEpochDuration),
     slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
     slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
-    slashingVetoer: EthAddress.fromString(slashingVetoer),
-    manaTarget: manaTarget,
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot,

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,10 +12,13 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: 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-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. */
@@ -26,18 +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!: SlotNumber;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -99,30 +106,40 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
     this.l1BlockNumber = newL1BlockNumber;
 
-    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
-    const timestamp = block.timestamp;
+    const [l2SlotNumber, l2Epoch, l1block] = await Promise.all([
+      this.rollup.getSlotNumber(),
+      this.rollup.getCurrentEpoch(),
+      this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false }),
+    ]);
+
+    const timestamp = l1block.timestamp;
     const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
 
     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.getEpochNumber(BigInt(newL2BlockNumber));
-      msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
-      this.l2BlockNumber = newL2BlockNumber;
-      this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', { l2BlockNumber: newL2BlockNumber, l1BlockNumber: newL1BlockNumber, timestamp });
+    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,
+        timestamp,
+      });
     }
 
-    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
-    if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(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,
       });
@@ -136,14 +153,17 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
     }
 
-    const [l2SlotNumber, l2Epoch] = await Promise.all([this.rollup.getSlotNumber(), this.rollup.getCurrentEpoch()]);
-
     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 });
-      msg += ` starting new epoch ${this.l2EpochNumber} with committee ${committee?.join(', ') ?? 'undefined'}`;
+      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, timestamp });
     }
 
     this.logger.info(msg, {
@@ -152,12 +172,74 @@ 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,
     });
 
     return this;
   }
+
+  public waitUntilL2Slot(slot: SlotNumber): Promise<void> {
+    if (this.l2SlotNumber >= slot) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2SlotNumber: SlotNumber; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= slot) {
+          this.off('l2-slot', listener);
+          resolve();
+        }
+      };
+      this.on('l2-slot', listener);
+    });
+  }
+
+  public waitUntilL1Block(block: number | bigint): Promise<void> {
+    const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
+    if (this.l1BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.l1BlockNumber >= targetBlock) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL1Timestamp(timestamp: number | bigint): Promise<void> {
+    const targetTimestamp = typeof timestamp === 'bigint' ? timestamp.valueOf() : timestamp;
+    if (this.l1BlockNumber >= targetTimestamp) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.timestamp >= targetTimestamp) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilCheckpoint(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.checkpointNumber >= checkpointNumber) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { checkpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.checkpointNumber >= checkpointNumber) {
+          this.off('checkpoint', listener);
+          resolve();
+        }
+      };
+      this.on('checkpoint', listener);
+    });
+  }
 }

package/src/test/delayed_tx_utils.ts

@@ -2,8 +2,8 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 
-import { type L1TxUtilsConfig, createViemSigner } from '../l1_tx_utils.js';
-import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { type L1TxUtilsConfig, createViemSigner } from '../l1_tx_utils/index.js';
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils/l1_tx_utils_with_blobs.js';
 import type { ExtendedViemWalletClient } from '../types.js';
 import { type Delayer, withDelayer } from './tx_delayer.js';