@aztec/ethereum 1.2.1 → 2.0.0-nightly.20250813

package/src/contracts/multicall.ts

@@ -18,12 +18,13 @@ export class Multicall3 {
     blobConfig: L1BlobInputs | undefined,
     rollupAddress: Hex,
     logger: Logger,
+    opts: { revertOnFailure?: boolean } = {},
   ) {
     requests = requests.filter(request => request.to !== null);
     const args = requests.map(r => ({
       target: r.to!,
       callData: r.data!,
-      allowFailure: false,
+      allowFailure: !opts.revertOnFailure,
     }));
     const forwarderFunctionData: Required<EncodeFunctionDataParameters<typeof multicall3Abi, 'aggregate3'>> = {
       abi: multicall3Abi,
@@ -119,6 +120,12 @@ export class Multicall3 {
 }
 
 export async function deployMulticall3(l1Client: ExtendedViemWalletClient, logger: Logger) {
+  const existing = await l1Client.getCode({ address: MULTI_CALL_3_ADDRESS });
+  if (existing && existing !== '0x') {
+    logger.verbose('Multicall3 already deployed', { address: MULTI_CALL_3_ADDRESS });
+    return;
+  }
+
   const deployer = '0x05f32b3cc3888453ff71b01135b34ff8e41263f2';
   const sendEth = await l1Client.sendTransaction({ to: deployer, value: 10n ** 17n });
   logger.info('Sent 0.1 ETH to deployer', { deployer, value: 10n ** 17n });

package/src/contracts/registry.ts

@@ -27,6 +27,10 @@ export class RegistryContract {
     this.registry = getContract({ address, abi: RegistryAbi, client });
   }
 
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.registry.read.owner());
+  }
+
   /**
    * Returns the address of the rollup for a given version.
    * @param version - The version of the rollup. 'canonical' can be used to get the canonical address (i.e. the latest version).

package/src/contracts/rollup.ts

@@ -5,13 +5,23 @@ import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import { RollupStorage } from '@aztec/l1-artifacts/RollupStorage';
 import { SlasherAbi } from '@aztec/l1-artifacts/SlasherAbi';
 
-import { type Account, type GetContractReturnType, type Hex, encodeFunctionData, getAddress, getContract } from 'viem';
+import {
+  type Account,
+  type GetContractReturnType,
+  type Hex,
+  type StateOverride,
+  encodeFunctionData,
+  getAddress,
+  getContract,
+  hexToBigInt,
+  keccak256,
+} from 'viem';
 
 import { getPublicClient } from '../client.js';
 import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { L1ReaderConfig } from '../l1_reader.js';
-import type { L1TxUtils } from '../l1_tx_utils.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { SlashingProposerContract } from './slashing_proposer.js';
@@ -87,6 +97,8 @@ export type ViemAppendOnlyTreeSnapshot = {
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
 
+  private static cachedStfStorageSlot: Hex | undefined;
+
   static get checkBlobStorageSlot(): bigint {
     const asString = RollupStorage.find(storage => storage.label === 'checkBlob')?.slot;
     if (asString === undefined) {
@@ -95,6 +107,10 @@ export class RollupContract {
     return BigInt(asString);
   }
 
+  static get stfStorageSlot(): Hex {
+    return (RollupContract.cachedStfStorageSlot ??= keccak256(Buffer.from('aztec.stf.storage', 'utf-8')));
+  }
+
   static getFromL1ContractsValues(deployL1ContractsValues: DeployL1ContractsReturnType) {
     const {
       l1Client,
@@ -131,7 +147,6 @@ export class RollupContract {
     return this.rollup;
   }
 
-  @memoize
   public async getSlashingProposer() {
     const slasherAddress = await this.rollup.read.getSlasher();
     const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
@@ -170,13 +185,13 @@ export class RollupContract {
   }
 
   @memoize
-  getMinimumStake() {
-    return this.rollup.read.getMinimumStake();
+  getEjectionThreshold() {
+    return this.rollup.read.getEjectionThreshold();
   }
 
   @memoize
-  getDepositAmount() {
-    return this.rollup.read.getDepositAmount();
+  getActivationThreshold() {
+    return this.rollup.read.getActivationThreshold();
   }
 
   @memoize
@@ -219,6 +234,10 @@ export class RollupContract {
     return this.rollup.read.getSlasher();
   }
 
+  getOwner() {
+    return this.rollup.read.owner();
+  }
+
   public async getSlashingProposerAddress() {
     const slasherAddress = await this.getSlasher();
     const slasher = getContract({
@@ -229,6 +248,10 @@ export class RollupContract {
     return EthAddress.fromString(await slasher.read.PROPOSER());
   }
 
+  getBlockReward() {
+    return this.rollup.read.getBlockReward();
+  }
+
   getBlockNumber() {
     return this.rollup.read.getPendingBlockNumber();
   }
@@ -387,6 +410,7 @@ export class RollupContract {
     args: readonly [
       ViemHeader,
       ViemCommitteeAttestations,
+      `0x${string}`[],
       `0x${string}`,
       `0x${string}`,
       {
@@ -400,7 +424,7 @@ export class RollupContract {
       await this.client.simulateContract({
         address: this.address,
         abi: RollupAbi,
-        functionName: 'validateHeader',
+        functionName: 'validateHeaderWithAttestations',
         args,
         account,
       });
@@ -493,12 +517,14 @@ export class RollupContract {
     archive: Buffer,
     account: `0x${string}` | Account,
     slotDuration: bigint | number,
+    opts: { forcePendingBlockNumber?: number } = {},
   ): Promise<{ slot: bigint; blockNumber: bigint; timeOfNextL1Slot: bigint }> {
     if (typeof slotDuration === 'number') {
       slotDuration = BigInt(slotDuration);
     }
     const latestBlock = await this.client.getBlock();
     const timeOfNextL1Slot = latestBlock.timestamp + slotDuration;
+    const who = typeof account === 'string' ? account : account.address;
 
     try {
       const {
@@ -507,8 +533,9 @@ export class RollupContract {
         address: this.address,
         abi: RollupAbi,
         functionName: 'canProposeAtTime',
-        args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`],
+        args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`, who],
         account,
+        stateOverride: await this.makePendingBlockNumberOverride(opts.forcePendingBlockNumber),
       });
 
       return { slot, blockNumber, timeOfNextL1Slot };
@@ -517,6 +544,69 @@ export class RollupContract {
     }
   }
 
+  /**
+   * Returns a state override that sets the pending block number to the specified value. Useful for simulations.
+   * Requires querying the current state of the contract to get the current proven block number, as they are both
+   * stored in the same slot. If the argument is undefined, it returns an empty override.
+   */
+  public async makePendingBlockNumberOverride(forcePendingBlockNumber: number | undefined): Promise<StateOverride> {
+    if (forcePendingBlockNumber === undefined) {
+      return [];
+    }
+    const slot = RollupContract.stfStorageSlot;
+    const currentValue = await this.client.getStorageAt({ address: this.address, slot });
+    const currentProvenBlockNumber = currentValue ? hexToBigInt(currentValue) & ((1n << 128n) - 1n) : 0n;
+    const newValue = (BigInt(forcePendingBlockNumber) << 128n) | currentProvenBlockNumber;
+    return [
+      {
+        address: this.address,
+        stateDiff: [{ slot, value: `0x${newValue.toString(16).padStart(64, '0')}` }],
+      },
+    ];
+  }
+
+  /** Creates a request to Rollup#invalidateBadAttestation to be simulated or sent */
+  public buildInvalidateBadAttestationRequest(
+    blockNumber: number,
+    attestations: ViemCommitteeAttestation[],
+    committee: EthAddress[],
+    invalidIndex: number,
+  ): L1TxRequest {
+    return {
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'invalidateBadAttestation',
+        args: [
+          BigInt(blockNumber),
+          RollupContract.packAttestations(attestations),
+          committee.map(addr => addr.toString()),
+          BigInt(invalidIndex),
+        ],
+      }),
+    };
+  }
+
+  /** Creates a request to Rollup#invalidateInsufficientAttestations to be simulated or sent */
+  public buildInvalidateInsufficientAttestationsRequest(
+    blockNumber: number,
+    attestations: ViemCommitteeAttestation[],
+    committee: EthAddress[],
+  ): L1TxRequest {
+    return {
+      to: this.address,
+      data: encodeFunctionData({
+        abi: RollupAbi,
+        functionName: 'invalidateInsufficientAttestations',
+        args: [
+          BigInt(blockNumber),
+          RollupContract.packAttestations(attestations),
+          committee.map(addr => addr.toString()),
+        ],
+      }),
+    };
+  }
+
   /** Calls getHasSubmitted directly. Returns whether the given prover has submitted a proof with the given length for the given epoch. */
   public getHasSubmittedProof(epochNumber: number, numberOfBlocksInEpoch: number, prover: Hex | EthAddress) {
     if (prover instanceof EthAddress) {
@@ -616,4 +706,20 @@ export class RollupContract {
       }),
     });
   }
+
+  public listenToSlasherChanged(callback: (args: { oldSlasher: `0x${string}`; newSlasher: `0x${string}` }) => unknown) {
+    return this.rollup.watchEvent.SlasherUpdated(
+      {},
+      {
+        onLogs: logs => {
+          for (const log of logs) {
+            const args = log.args;
+            if (args.oldSlasher && args.newSlasher) {
+              callback(args as { oldSlasher: `0x${string}`; newSlasher: `0x${string}` });
+            }
+          }
+        },
+      },
+    );
+  }
 }

package/src/contracts/slashing_proposer.ts

@@ -1,4 +1,5 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { SlashingProposerAbi } from '@aztec/l1-artifacts/SlashingProposerAbi';
 
@@ -7,6 +8,7 @@ import {
   type EncodeFunctionDataParameters,
   type GetContractReturnType,
   type Hex,
+  type TypedDataDefinition,
   encodeFunctionData,
   getContract,
 } from 'viem';
@@ -14,7 +16,7 @@ import {
 import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemClient } from '../types.js';
 import { FormattedViemError } from '../utils.js';
-import { type IEmpireBase, encodeVote, encodeVoteWithSignature, signVoteWithSig } from './empire_base.js';
+import { type IEmpireBase, encodeSignal, encodeSignalWithSignature, signSignalWithSig } from './empire_base.js';
 
 export class ProposalAlreadyExecutedError extends Error {
   constructor(round: bigint) {
@@ -23,6 +25,7 @@ export class ProposalAlreadyExecutedError extends Error {
 }
 
 export class SlashingProposerContract extends EventEmitter implements IEmpireBase {
+  private readonly logger = createLogger('SlashingProposerContract');
   private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, ViemClient>;
 
   constructor(
@@ -38,11 +41,23 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
   }
 
   public getQuorumSize() {
-    return this.proposer.read.N();
+    return this.proposer.read.QUORUM_SIZE();
   }
 
   public getRoundSize() {
-    return this.proposer.read.M();
+    return this.proposer.read.ROUND_SIZE();
+  }
+
+  public getLifetimeInRounds() {
+    return this.proposer.read.LIFETIME_IN_ROUNDS();
+  }
+
+  public getExecutionDelayInRounds() {
+    return this.proposer.read.EXECUTION_DELAY_IN_ROUNDS();
+  }
+
+  public getCurrentRound() {
+    return this.proposer.read.getCurrentRound();
   }
 
   public computeRound(slot: bigint): Promise<bigint> {
@@ -56,45 +71,46 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
   public async getRoundInfo(
     rollupAddress: Hex,
     round: bigint,
-  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
+  ): Promise<{ lastSignalSlot: bigint; payloadWithMostSignals: Hex; executed: boolean }> {
     return await this.proposer.read.getRoundData([rollupAddress, round]);
   }
 
-  public getProposalVotes(rollupAddress: Hex, round: bigint, proposal: Hex): Promise<bigint> {
-    return this.proposer.read.yeaCount([rollupAddress, round, proposal]);
+  public getPayloadSignals(rollupAddress: Hex, round: bigint, payload: Hex): Promise<bigint> {
+    return this.proposer.read.signalCount([rollupAddress, round, payload]);
   }
 
-  public createVoteRequest(payload: Hex): L1TxRequest {
+  public createSignalRequest(payload: Hex): L1TxRequest {
     return {
       to: this.address.toString(),
-      data: encodeVote(payload),
+      data: encodeSignal(payload),
     };
   }
 
-  public async createVoteRequestWithSignature(
+  public async createSignalRequestWithSignature(
     payload: Hex,
+    round: bigint,
     chainId: number,
     signerAddress: Hex,
-    signer: (msg: Hex) => Promise<Hex>,
+    signer: (msg: TypedDataDefinition) => Promise<Hex>,
   ): Promise<L1TxRequest> {
     const nonce = await this.getNonce(signerAddress);
-    const signature = await signVoteWithSig(signer, payload, nonce, this.address.toString(), chainId);
+    const signature = await signSignalWithSig(signer, payload, nonce, round, this.address.toString(), chainId);
     return {
       to: this.address.toString(),
-      data: encodeVoteWithSignature(payload, signature),
+      data: encodeSignalWithSignature(payload, signature),
     };
   }
 
-  public listenToExecutableProposals(callback: (args: { proposal: `0x${string}`; round: bigint }) => unknown) {
-    return this.proposer.watchEvent.ProposalExecutable(
+  public listenToSubmittablePayloads(callback: (args: { payload: `0x${string}`; round: bigint }) => unknown) {
+    return this.proposer.watchEvent.PayloadSubmittable(
       {},
       {
         onLogs: logs => {
           for (const payload of logs) {
             const args = payload.args;
-            if (args.proposal && args.round) {
+            if (args.payload && args.round) {
               // why compiler can't figure it out? no one knows
-              callback(args as { proposal: `0x${string}`; round: bigint });
+              callback(args as { payload: `0x${string}`; round: bigint });
             }
           }
         },
@@ -102,15 +118,15 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
     );
   }
 
-  public listenToProposalExecuted(callback: (args: { round: bigint; proposal: `0x${string}` }) => unknown) {
-    return this.proposer.watchEvent.ProposalExecuted(
+  public listenToPayloadSubmitted(callback: (args: { round: bigint; payload: `0x${string}` }) => unknown) {
+    return this.proposer.watchEvent.PayloadSubmitted(
       {},
       {
         onLogs: logs => {
           for (const payload of logs) {
             const args = payload.args;
-            if (args.round && args.proposal) {
-              callback(args as { round: bigint; proposal: `0x${string}` });
+            if (args.round && args.payload) {
+              callback(args as { round: bigint; payload: `0x${string}` });
             }
           }
         },
@@ -118,16 +134,26 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
     );
   }
 
-  public waitForRound(round: bigint, pollingIntervalSeconds: number = 1) {
+  /**
+   * Wait for a round to be reached.
+   *
+   * @param round - The round to wait for.
+   * @param pollingIntervalSeconds - The interval in seconds to poll for the round.
+   * @returns True if the round was reached, false otherwise.
+   */
+  public waitForRound(round: bigint, pollingIntervalSeconds: number = 1): Promise<boolean> {
     return retryUntil(
       async () => {
-        const currentRound = await this.proposer.read.getCurrentRound();
-        return currentRound >= round;
+        const currentRound = await this.proposer.read.getCurrentRound().catch(e => {
+          this.logger.error('Error getting current round', e);
+          return undefined;
+        });
+        return currentRound !== undefined && currentRound >= round;
       },
       `Waiting for round ${round} to be reached`,
       0, // no timeout
       pollingIntervalSeconds,
-    );
+    ).catch(() => false);
   }
 
   public async executeRound(
@@ -137,9 +163,9 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
     if (typeof round === 'number') {
       round = BigInt(round);
     }
-    const args: EncodeFunctionDataParameters<typeof SlashingProposerAbi, 'executeProposal'> = {
+    const args: EncodeFunctionDataParameters<typeof SlashingProposerAbi, 'submitRoundWinner'> = {
       abi: SlashingProposerAbi,
-      functionName: 'executeProposal',
+      functionName: 'submitRoundWinner',
       args: [round],
     };
     const data = encodeFunctionData(args);
@@ -175,7 +201,9 @@ export class SlashingProposerContract extends EventEmitter implements IEmpireBas
       if (error?.includes('ProposalAlreadyExecuted')) {
         throw new ProposalAlreadyExecutedError(round);
       }
-      const errorMessage = `Failed to execute round ${round}, TxHash: ${response.receipt.transactionHash}, Error: ${error ?? 'Unknown error'}`;
+      const errorMessage = `Failed to execute round ${round}, TxHash: ${response.receipt.transactionHash}, Error: ${
+        error ?? 'Unknown error'
+      }`;
       throw new Error(errorMessage);
     }
     return response;