@aztec/ethereum 0.86.0 → 0.87.0-nightly.20250521

package/dest/utils.js

@@ -101,7 +101,7 @@ function getNestedErrorData(error) {
                 return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
             }
         }
-    } catch (decodeErr) {
+    } catch  {
     // If decoding fails, we fall back to the original formatting
     }
     // Strip ABI from the error object before formatting
@@ -309,7 +309,7 @@ export function tryGetCustomErrorName(err) {
                 return revertError.data?.errorName;
             }
         }
-    } catch (_e) {
+    } catch  {
         return undefined;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "0.86.0",
+  "version": "0.87.0-nightly.20250521",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -32,9 +32,9 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/blob-lib": "0.86.0",
-    "@aztec/foundation": "0.86.0",
-    "@aztec/l1-artifacts": "0.86.0",
+    "@aztec/blob-lib": "0.87.0-nightly.20250521",
+    "@aztec/foundation": "0.87.0-nightly.20250521",
+    "@aztec/l1-artifacts": "0.87.0-nightly.20250521",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "tslib": "^2.4.0",
@@ -44,13 +44,13 @@
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
-    "@types/node": "^18.14.6",
+    "@types/node": "^22.15.17",
     "@viem/anvil": "^0.0.10",
     "get-port": "^7.1.0",
     "jest": "^29.5.0",
     "lodash.omit": "^4.5.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -92,6 +92,6 @@
     ]
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/client.ts

@@ -54,7 +54,7 @@ async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Log
       let chainId = 0;
       try {
         chainId = await client.getChainId();
-      } catch (err) {
+      } catch {
         logger?.warn(`Failed to connect to Ethereum node at ${config.l1RpcUrls.join(', ')}. Retrying...`);
       }
       return chainId;
@@ -73,7 +73,7 @@ async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Log
 
 export function createExtendedL1Client(
   rpcUrls: string[],
-  mnemonicOrPrivateKeyOrHdAccount: string | `0x${string}` | HDAccount | PrivateKeyAccount | LocalAccount,
+  mnemonicOrPrivateKeyOrHdAccount: string | HDAccount | PrivateKeyAccount | LocalAccount,
   chain: Chain = foundry,
   pollingIntervalMS?: number,
   addressIndex?: number,

package/src/contracts/errors.ts

@@ -0,0 +1,6 @@
+export class BlockTagTooOldError extends Error {
+  constructor(blockTag: bigint | number, latestBlock: bigint | number) {
+    super(`Block tag ${blockTag} is more than 128 blocks behind the latest block ${latestBlock}`);
+    this.name = 'BlockTagTooOldError';
+  }
+}

package/src/contracts/fee_asset_handler.ts

@@ -8,7 +8,10 @@ import type { L1TxUtils } from '../l1_tx_utils.js';
 export class FeeAssetHandlerContract {
   public address: EthAddress;
 
-  constructor(address: Hex, public readonly txUtils: L1TxUtils) {
+  constructor(
+    address: Hex,
+    public readonly txUtils: L1TxUtils,
+  ) {
     this.address = EthAddress.fromString(address);
   }
 

package/src/contracts/fee_juice.ts

@@ -8,7 +8,10 @@ import { type ExtendedViemWalletClient, type ViemClient, isExtendedClient } from
 export class FeeJuiceContract {
   private readonly feeJuiceContract: GetContractReturnType<typeof FeeJuiceAbi, ViemClient>;
 
-  constructor(address: Hex, public readonly client: ViemClient) {
+  constructor(
+    address: Hex,
+    public readonly client: ViemClient,
+  ) {
     this.feeJuiceContract = getContract({ address, abi: FeeJuiceAbi, client });
   }
 

package/src/contracts/forwarder.ts

@@ -19,7 +19,11 @@ import { RollupContract } from './rollup.js';
 export class ForwarderContract {
   private readonly forwarder: GetContractReturnType<typeof ForwarderAbi, ViemClient>;
 
-  constructor(public readonly client: ExtendedViemWalletClient, address: Hex, public readonly rollupAddress: Hex) {
+  constructor(
+    public readonly client: ExtendedViemWalletClient,
+    address: Hex,
+    public readonly rollupAddress: Hex,
+  ) {
     this.forwarder = getContract({ address, abi: ForwarderAbi, client });
   }
 

package/src/contracts/governance.ts

@@ -50,7 +50,10 @@ export function extractProposalIdFromLogs(logs: Log[]): bigint {
 export class ReadOnlyGovernanceContract {
   protected readonly governanceContract: GetContractReturnType<typeof GovernanceAbi, ViemClient>;
 
-  constructor(address: Hex, public readonly client: ViemClient) {
+  constructor(
+    address: Hex,
+    public readonly client: ViemClient,
+  ) {
     this.governanceContract = getContract({ address, abi: GovernanceAbi, client: client });
   }
 
@@ -72,6 +75,7 @@ export class ReadOnlyGovernanceContract {
 
   public async getProposalState(proposalId: bigint): Promise<ProposalState> {
     const state = await this.governanceContract.read.getProposalState([proposalId]);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
     if (state < 0 || state > ProposalState.Expired) {
       throw new Error(`Invalid proposal state: ${state}`);
     }
@@ -131,7 +135,10 @@ export class ReadOnlyGovernanceContract {
 export class GovernanceContract extends ReadOnlyGovernanceContract {
   protected override readonly governanceContract: GetContractReturnType<typeof GovernanceAbi, ExtendedViemWalletClient>;
 
-  constructor(address: Hex, public override readonly client: ExtendedViemWalletClient) {
+  constructor(
+    address: Hex,
+    public override readonly client: ExtendedViemWalletClient,
+  ) {
     super(address, client);
     if (!isExtendedClient(client)) {
       throw new Error('GovernanceContract has to be instantiated with a wallet client.');

package/src/contracts/governance_proposer.ts

@@ -12,7 +12,10 @@ import { extractProposalIdFromLogs } from './governance.js';
 export class GovernanceProposerContract implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, ViemClient>;
 
-  constructor(public readonly client: ViemClient, address: Hex) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex,
+  ) {
     this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
   }
 

package/src/contracts/inbox.ts

@@ -0,0 +1,63 @@
+import { Buffer16 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { InboxAbi } from '@aztec/l1-artifacts/InboxAbi';
+
+import { type BlockTag, type GetContractReturnType, type Hex, getContract } from 'viem';
+
+import { getPublicClient } from '../client.js';
+import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
+import type { L1ReaderConfig } from '../l1_reader.js';
+import type { ViemClient } from '../types.js';
+import { checkBlockTag } from './utils.js';
+
+export class InboxContract {
+  private readonly inbox: GetContractReturnType<typeof InboxAbi, ViemClient>;
+
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1ContractsReturnType) {
+    const {
+      l1Client,
+      l1ContractAddresses: { inboxAddress },
+    } = deployL1ContractsValues;
+    return new InboxContract(l1Client, inboxAddress.toString());
+  }
+
+  static getFromConfig(config: L1ReaderConfig) {
+    const client = getPublicClient(config);
+    const address = config.l1Contracts.inboxAddress.toString();
+    return new InboxContract(client, address);
+  }
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.inbox = getContract({ address, abi: InboxAbi, client });
+  }
+
+  public get address() {
+    return this.inbox.address;
+  }
+
+  public getContract(): GetContractReturnType<typeof InboxAbi, ViemClient> {
+    return this.inbox;
+  }
+
+  public async getState(opts: { blockTag?: BlockTag; blockNumber?: bigint } = {}): Promise<InboxContractState> {
+    await checkBlockTag(opts.blockNumber, this.client);
+    const state = await this.inbox.read.getState(opts);
+    return {
+      totalMessagesInserted: state.totalMessagesInserted,
+      messagesRollingHash: Buffer16.fromString(state.rollingHash),
+      treeInProgress: state.inProgress,
+    };
+  }
+}
+
+export type InboxContractState = {
+  totalMessagesInserted: bigint;
+  messagesRollingHash: Buffer16;
+  treeInProgress: bigint;
+};

package/src/contracts/index.ts

@@ -4,6 +4,8 @@ export * from './fee_juice.js';
 export * from './forwarder.js';
 export * from './governance.js';
 export * from './governance_proposer.js';
+export * from './inbox.js';
 export * from './registry.js';
 export * from './rollup.js';
 export * from './slashing_proposer.js';
+export * from './errors.js';

package/src/contracts/registry.ts

@@ -16,7 +16,10 @@ export class RegistryContract {
   private readonly log = createLogger('ethereum:contracts:registry');
   private readonly registry: GetContractReturnType<typeof RegistryAbi, ViemClient>;
 
-  constructor(public readonly client: ViemClient, address: Hex | EthAddress) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
@@ -40,7 +43,7 @@ export class RegistryContract {
 
     try {
       return EthAddress.fromString(await this.registry.read.getRollup([version]));
-    } catch (e) {
+    } catch {
       this.log.warn(`Failed fetching rollup address for version ${version}. Retrying as index.`);
     }
 
@@ -48,7 +51,7 @@ export class RegistryContract {
       const actualVersion = await this.registry.read.getVersion([version]);
       const rollupAddress = await this.registry.read.getRollup([actualVersion]);
       return EthAddress.fromString(rollupAddress);
-    } catch (e) {
+    } catch {
       throw new Error('Rollup address is undefined');
     }
   }

package/src/contracts/rollup.ts

@@ -14,6 +14,7 @@ import type { L1ReaderConfig } from '../l1_reader.js';
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { SlashingProposerContract } from './slashing_proposer.js';
+import { checkBlockTag } from './utils.js';
 
 export type L1RollupContractAddresses = Pick<
   L1ContractAddresses,
@@ -60,7 +61,10 @@ export class RollupContract {
     return new RollupContract(client, address);
   }
 
-  constructor(public readonly client: ViemClient, address: Hex | EthAddress) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
     if (address instanceof EthAddress) {
       address = address.toString();
     }
@@ -175,6 +179,14 @@ export class RollupContract {
     return this.rollup.read.getCurrentSlot();
   }
 
+  getL1FeesAt(timestamp: bigint) {
+    return this.rollup.read.getL1FeesAt([timestamp]);
+  }
+
+  getFeeAssetPerEth() {
+    return this.rollup.read.getFeeAssetPerEth();
+  }
+
   async getCommitteeAt(timestamp: bigint) {
     const { result } = await this.client.simulateContract({
       address: this.address,
@@ -381,11 +393,13 @@ export class RollupContract {
     return this.rollup.read.getSlotAt([timestamp]);
   }
 
-  status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+  async status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+    await checkBlockTag(options?.blockNumber, this.client);
     return this.rollup.read.status([blockNumber], options);
   }
 
-  canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
+  async canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
+    await checkBlockTag(options?.blockNumber, this.client);
     return this.rollup.read.canPruneAtTime([timestamp], options);
   }
 

package/src/contracts/slashing_proposer.ts

@@ -10,7 +10,10 @@ import { type IEmpireBase, encodeVote } from './empire_base.js';
 export class SlashingProposerContract implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, ViemClient>;
 
-  constructor(public readonly client: ViemClient, address: Hex) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex,
+  ) {
     this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
   }
 

package/src/contracts/utils.ts

@@ -0,0 +1,14 @@
+import type { ViemClient } from '../types.js';
+import { BlockTagTooOldError } from './errors.js';
+
+const L1_NON_ARCHIVE_BLOCK_HISTORY_LENGTH = 128n;
+
+export async function checkBlockTag(block: bigint | undefined, publicClient: ViemClient) {
+  if (block === undefined) {
+    return;
+  }
+  const latestBlock = await publicClient.getBlockNumber();
+  if (block < latestBlock - L1_NON_ARCHIVE_BLOCK_HISTORY_LENGTH) {
+    throw new BlockTagTooOldError(block, latestBlock);
+  }
+}

package/src/deploy_l1_contracts.ts

@@ -18,6 +18,8 @@ import {
   GovernanceProposerBytecode,
   InboxAbi,
   InboxBytecode,
+  MultiAdderAbi,
+  MultiAdderBytecode,
   OutboxAbi,
   OutboxBytecode,
   RegisterNewRollupVersionPayloadAbi,
@@ -193,6 +195,10 @@ export const l1Artifacts = {
     contractAbi: StakingAssetHandlerAbi,
     contractBytecode: StakingAssetHandlerBytecode as Hex,
   },
+  multiAdder: {
+    contractAbi: MultiAdderAbi,
+    contractBytecode: MultiAdderBytecode as Hex,
+  },
 };
 
 export interface DeployL1ContractsArgs extends L1ContractsConfig {
@@ -550,7 +556,7 @@ export const deployRollup = async (
     try {
       const retrievedRollupAddress = await registryContract.read.getRollup([version]);
       logger.verbose(`Rollup ${retrievedRollupAddress} already exists in registry`);
-    } catch (e) {
+    } catch {
       const { txHash: addRollupTxHash } = await deployer.sendTransaction({
         to: addresses.registryAddress.toString(),
         data: encodeFunctionData({
@@ -664,6 +670,18 @@ export const cheat_initializeValidatorSet = async (
     }
 
     if (validators.length > 0) {
+      const multiAdder = await deployer.deploy(l1Artifacts.multiAdder, [
+        rollupAddress,
+        deployer.client.account.address,
+      ]);
+
+      const validatorsTuples = validators.map(v => ({
+        attester: v,
+        proposer: getExpectedAddress(ForwarderAbi, ForwarderBytecode, [v], v).address,
+        withdrawer: v,
+        amount: minimumStake,
+      }));
+
       // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
       const stakeNeeded = minimumStake * BigInt(validators.length);
       await Promise.all(
@@ -673,30 +691,16 @@ export const cheat_initializeValidatorSet = async (
             data: encodeFunctionData({
               abi: l1Artifacts.stakingAsset.contractAbi,
               functionName: 'mint',
-              args: [extendedClient.account.address, stakeNeeded],
-            }),
-          }),
-          await deployer.sendTransaction({
-            to: stakingAssetAddress,
-            data: encodeFunctionData({
-              abi: l1Artifacts.stakingAsset.contractAbi,
-              functionName: 'approve',
-              args: [rollupAddress, stakeNeeded],
+              args: [multiAdder.toString(), stakeNeeded],
             }),
           }),
         ].map(tx => extendedClient.waitForTransactionReceipt({ hash: tx.txHash })),
       );
 
-      const validatorsTuples = validators.map(v => ({
-        attester: v,
-        proposer: getExpectedAddress(ForwarderAbi, ForwarderBytecode, [v], v).address,
-        withdrawer: v,
-        amount: minimumStake,
-      }));
       const initiateValidatorSetTxHash = await deployer.client.writeContract({
-        address: rollupAddress,
-        abi: l1Artifacts.rollup.contractAbi,
-        functionName: 'cheat__InitialiseValidatorSet',
+        address: multiAdder.toString(),
+        abi: l1Artifacts.multiAdder.contractAbi,
+        functionName: 'addValidators',
         args: [validatorsTuples],
       });
       await extendedClient.waitForTransactionReceipt({ hash: initiateValidatorSetTxHash });

package/src/eth_cheat_codes.ts

@@ -4,7 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 
-import { type Hex, createPublicClient, fallback, http } from 'viem';
+import { type Hex, createPublicClient, fallback, http, parseTransaction } from 'viem';
 
 import type { ViemPublicClient } from './types.js';
 
@@ -336,6 +336,13 @@ export class EthCheatCodes {
     depth: number,
     newBlocks: (Hex | { to: EthAddress | Hex; input?: Hex; from?: EthAddress | Hex; value?: number | bigint })[][] = [],
   ): Promise<void> {
+    this.logger.verbose(`Preparing L1 reorg with depth ${depth}`);
+    for (const tx of newBlocks.flat()) {
+      const isBlobTx = typeof tx === 'string' ? parseTransaction(tx).type === 'eip4844' : 'blobVersionedHashes' in tx;
+      if (isBlobTx) {
+        throw new Error(`Anvil does not support blob transactions in anvil_reorg`);
+      }
+    }
     try {
       await this.rpcCall('anvil_reorg', [
         depth,

package/src/index.ts

@@ -12,3 +12,4 @@ export * from './contracts/index.js';
 export * from './queries.js';
 export * from './client.js';
 export * from './account.js';
+export * from './l1_types.js';

package/src/l1_tx_utils.ts

@@ -167,6 +167,7 @@ export interface L1TxRequest {
   to: Address | null;
   data?: Hex;
   value?: bigint;
+  abi?: Abi;
 }
 
 export type L1GasConfig = Partial<L1TxUtilsConfig> & { gasLimit?: bigint; txTimeoutAt?: Date };
@@ -595,7 +596,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
       return { txHash, gasLimit, gasPrice };
     } catch (err: any) {
-      const viemError = formatViemError(err);
+      const viemError = formatViemError(err, request.abi);
       this.logger?.error(`Failed to send L1 transaction`, viemError.message, {
         metaMessages: viemError.metaMessages,
       });

package/src/l1_types.ts

@@ -0,0 +1,6 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+
+export type L1BlockId = {
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+};

package/src/test/chain_monitor.ts

@@ -1,4 +1,4 @@
-import type { RollupContract } from '@aztec/ethereum/contracts';
+import { InboxContract, type RollupContract } from '@aztec/ethereum/contracts';
 import { createLogger } from '@aztec/foundation/log';
 
 import { EventEmitter } from 'events';
@@ -8,6 +8,7 @@ import type { ViemClient } from '../types.js';
 /** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
 export class ChainMonitor extends EventEmitter {
   private readonly l1Client: ViemClient;
+  private inbox: InboxContract | undefined;
   private handle: NodeJS.Timeout | undefined;
 
   /** Current L1 block number */
@@ -20,6 +21,8 @@ export class ChainMonitor extends EventEmitter {
   public l2BlockTimestamp!: bigint;
   /** L1 timestamp for the proven L2 block */
   public l2ProvenBlockTimestamp!: bigint;
+  /** Total number of L2 messages pushed into the Inbox */
+  public totalL2Messages: number = 0;
 
   constructor(
     private readonly rollup: RollupContract,
@@ -46,16 +49,24 @@ export class ChainMonitor extends EventEmitter {
     }
   }
 
+  private async getInbox() {
+    if (!this.inbox) {
+      const { inboxAddress } = await this.rollup.getRollupAddresses();
+      this.inbox = new InboxContract(this.l1Client, inboxAddress);
+    }
+    return this.inbox;
+  }
+
   private safeRun() {
     void this.run().catch(error => {
       this.logger.error('Error in chain monitor loop', error);
     });
   }
 
-  async run() {
+  async run(force = false) {
     const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({ cacheTime: 0 }));
-    if (this.l1BlockNumber === newL1BlockNumber) {
-      return;
+    if (!force && this.l1BlockNumber === newL1BlockNumber) {
+      return this;
     }
     this.l1BlockNumber = newL1BlockNumber;
 
@@ -88,12 +99,23 @@ export class ChainMonitor extends EventEmitter {
       });
     }
 
+    const inbox = await this.getInbox();
+    const newTotalL2Messages = await inbox.getState().then(s => Number(s.totalMessagesInserted));
+    if (this.totalL2Messages !== newTotalL2Messages) {
+      msg += ` with ${newTotalL2Messages - this.totalL2Messages} new L2 messages (total ${newTotalL2Messages})`;
+      this.totalL2Messages = newTotalL2Messages;
+      this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
+    }
+
     this.logger.info(msg, {
       l1Timestamp: timestamp,
       l1BlockNumber: this.l1BlockNumber,
       l2SlotNumber: await this.rollup.getSlotNumber(),
       l2BlockNumber: this.l2BlockNumber,
       l2ProvenBlockNumber: this.l2ProvenBlockNumber,
+      totalL2Messages: this.totalL2Messages,
     });
+
+    return this;
   }
 }