@aztec/ethereum 0.73.0 → 0.74.0

package/src/contracts/empire_base.ts

@@ -0,0 +1,19 @@
+import { EmpireBaseAbi } from '@aztec/l1-artifacts/EmpireBaseAbi';
+
+import { type Hex, encodeFunctionData } from 'viem';
+
+import { type L1TxRequest } from '../l1_tx_utils.js';
+
+export interface IEmpireBase {
+  getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }>;
+  computeRound(slot: bigint): Promise<bigint>;
+  createVoteRequest(payload: Hex): L1TxRequest;
+}
+
+export function encodeVote(payload: Hex): Hex {
+  return encodeFunctionData({
+    abi: EmpireBaseAbi,
+    functionName: 'vote',
+    args: [payload],
+  });
+}

package/src/contracts/forwarder.ts

@@ -1,9 +1,11 @@
+import { toHex } from '@aztec/foundation/bigint-buffer';
 import { type Logger } from '@aztec/foundation/log';
 import { ForwarderAbi, ForwarderBytecode } from '@aztec/l1-artifacts';
 
 import {
   type Account,
   type Chain,
+  type EncodeFunctionDataParameters,
   type GetContractReturnType,
   type Hex,
   type HttpTransport,
@@ -15,11 +17,12 @@ import {
 
 import { type L1Clients, deployL1Contract } from '../deploy_l1_contracts.js';
 import { type L1BlobInputs, type L1GasConfig, type L1TxRequest, type L1TxUtils } from '../l1_tx_utils.js';
+import { RollupContract } from './rollup.js';
 
 export class ForwarderContract {
   private readonly forwarder: GetContractReturnType<typeof ForwarderAbi, PublicClient<HttpTransport, Chain>>;
 
-  constructor(public readonly client: L1Clients['publicClient'], address: Hex) {
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex, public readonly rollupAddress: Hex) {
     this.forwarder = getContract({ address, abi: ForwarderAbi, client });
   }
 
@@ -28,6 +31,7 @@ export class ForwarderContract {
     walletClient: WalletClient<HttpTransport, Chain, Account>,
     publicClient: PublicClient<HttpTransport, Chain>,
     logger: Logger,
+    rollupAddress: Hex,
   ) {
     logger.info('Deploying forwarder contract');
 
@@ -48,7 +52,7 @@ export class ForwarderContract {
 
     logger.info(`Forwarder contract deployed at ${address} with owner ${owner}`);
 
-    return new ForwarderContract(publicClient, address.toString());
+    return new ForwarderContract(publicClient, address.toString(), rollupAddress);
   }
 
   public getAddress() {
@@ -60,20 +64,22 @@ export class ForwarderContract {
     l1TxUtils: L1TxUtils,
     gasConfig: L1GasConfig | undefined,
     blobConfig: L1BlobInputs | undefined,
+    logger: Logger,
   ) {
     requests = requests.filter(request => request.to !== null);
     const toArgs = requests.map(request => request.to!);
     const dataArgs = requests.map(request => request.data!);
-    const data = encodeFunctionData({
+    const forwarderFunctionData: EncodeFunctionDataParameters<typeof ForwarderAbi, 'forward'> = {
       abi: ForwarderAbi,
       functionName: 'forward',
       args: [toArgs, dataArgs],
-    });
+    };
+    const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
 
     const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction(
       {
         to: this.forwarder.address,
-        data,
+        data: encodedForwarderData,
       },
       gasConfig,
       blobConfig,
@@ -83,10 +89,10 @@ export class ForwarderContract {
       const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
       return { receipt, gasPrice, stats };
     } else {
+      logger.error('Forwarder transaction failed', undefined, { receipt });
+
       const args = {
-        args: [toArgs, dataArgs],
-        functionName: 'forward',
-        abi: ForwarderAbi,
+        ...forwarderFunctionData,
         address: this.forwarder.address,
       };
 
@@ -97,14 +103,31 @@ export class ForwarderContract {
         if (maxFeePerBlobGas === undefined) {
           errorMsg = 'maxFeePerBlobGas is required to get the error message';
         } else {
-          errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(data, args, {
-            blobs: blobConfig.blobs,
-            kzg: blobConfig.kzg,
-            maxFeePerBlobGas,
-          });
+          logger.debug('Trying to get error from reverted tx with blob config');
+          errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(
+            encodedForwarderData,
+            args,
+            {
+              blobs: blobConfig.blobs,
+              kzg: blobConfig.kzg,
+              maxFeePerBlobGas,
+            },
+            [
+              {
+                address: this.rollupAddress,
+                stateDiff: [
+                  {
+                    slot: toHex(RollupContract.checkBlobStorageSlot, true),
+                    value: toHex(0n, true),
+                  },
+                ],
+              },
+            ],
+          );
         }
       } else {
-        errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(data, args);
+        logger.debug('Trying to get error from reverted tx without blob config');
+        errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, undefined, []);
       }
 
       return { receipt, gasPrice, errorMsg };

package/src/contracts/governance_proposer.ts

@@ -8,13 +8,19 @@ import {
   type Hex,
   type HttpTransport,
   type PublicClient,
+  type TransactionReceipt,
+  encodeFunctionData,
   getContract,
 } from 'viem';
 
-export class GovernanceProposerContract {
+import type { L1Clients } from '../deploy_l1_contracts.js';
+import type { GasPrice, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
+import { type IEmpireBase, encodeVote } from './empire_base.js';
+
+export class GovernanceProposerContract implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, PublicClient<HttpTransport, Chain>>;
 
-  constructor(public readonly client: PublicClient<HttpTransport, Chain>, address: Hex) {
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex) {
     this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
   }
 
@@ -31,11 +37,55 @@ export class GovernanceProposerContract {
     return EthAddress.fromString(await this.proposer.read.REGISTRY());
   }
 
-  public getQuorumSize() {
+  public getQuorumSize(): Promise<bigint> {
     return this.proposer.read.N();
   }
 
-  public getRoundSize() {
+  public getRoundSize(): Promise<bigint> {
     return this.proposer.read.M();
   }
+
+  public computeRound(slot: bigint): Promise<bigint> {
+    return this.proposer.read.computeRound([slot]);
+  }
+
+  public async getRoundInfo(
+    rollupAddress: Hex,
+    round: bigint,
+  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
+    const roundInfo = await this.proposer.read.rounds([rollupAddress, round]);
+    return {
+      lastVote: roundInfo[0],
+      leader: roundInfo[1],
+      executed: roundInfo[2],
+    };
+  }
+
+  public getProposalVotes(rollupAddress: Hex, round: bigint, proposal: Hex): Promise<bigint> {
+    return this.proposer.read.yeaCount([rollupAddress, round, proposal]);
+  }
+
+  public createVoteRequest(payload: Hex): L1TxRequest {
+    return {
+      to: this.address.toString(),
+      data: encodeVote(payload),
+    };
+  }
+
+  public executeProposal(
+    round: bigint,
+    l1TxUtils: L1TxUtils,
+  ): Promise<{
+    receipt: TransactionReceipt;
+    gasPrice: GasPrice;
+  }> {
+    return l1TxUtils.sendAndMonitorTransaction({
+      to: this.address.toString(),
+      data: encodeFunctionData({
+        abi: this.proposer.abi,
+        functionName: 'executeProposal',
+        args: [round],
+      }),
+    });
+  }
 }

package/src/contracts/index.ts

@@ -1,5 +1,6 @@
+export * from './empire_base.js';
 export * from './forwarder.js';
-export * from './rollup.js';
 export * from './governance.js';
 export * from './governance_proposer.js';
+export * from './rollup.js';
 export * from './slashing_proposer.js';

package/src/contracts/rollup.ts

@@ -1,7 +1,7 @@
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
-import { RollupAbi, SlasherAbi } from '@aztec/l1-artifacts';
+import { RollupAbi, RollupStorage, SlasherAbi } from '@aztec/l1-artifacts';
 
 import {
   type Account,
@@ -45,6 +45,14 @@ export type EpochProofQuoteViemArgs = {
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>;
 
+  static get checkBlobStorageSlot(): bigint {
+    const asString = RollupStorage.find(storage => storage.label === 'checkBlob')?.slot;
+    if (asString === undefined) {
+      throw new Error('checkBlobStorageSlot not found');
+    }
+    return BigInt(asString);
+  }
+
   static getFromL1ContractsValues(deployL1ContractsValues: DeployL1Contracts) {
     const {
       publicClient,
@@ -72,7 +80,7 @@ export class RollupContract {
 
   @memoize
   public async getSlashingProposer() {
-    const slasherAddress = await this.rollup.read.SLASHER();
+    const slasherAddress = await this.rollup.read.getSlasher();
     const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
     const proposerAddress = await slasher.read.PROPOSER();
     return new SlashingProposerContract(this.client, proposerAddress);
@@ -85,7 +93,7 @@ export class RollupContract {
 
   @memoize
   getL1GenesisTime() {
-    return this.rollup.read.GENESIS_TIME();
+    return this.rollup.read.getGenesisTime();
   }
 
   @memoize
@@ -95,12 +103,12 @@ export class RollupContract {
 
   @memoize
   getEpochDuration() {
-    return this.rollup.read.EPOCH_DURATION();
+    return this.rollup.read.getEpochDuration();
   }
 
   @memoize
   getSlotDuration() {
-    return this.rollup.read.SLOT_DURATION();
+    return this.rollup.read.getSlotDuration();
   }
 
   @memoize
@@ -110,11 +118,11 @@ export class RollupContract {
 
   @memoize
   getMinimumStake() {
-    return this.rollup.read.MINIMUM_STAKE();
+    return this.rollup.read.getMinimumStake();
   }
 
   public async getSlashingProposerAddress() {
-    const slasherAddress = await this.rollup.read.SLASHER();
+    const slasherAddress = await this.rollup.read.getSlasher();
     const slasher = getContract({
       address: getAddress(slasherAddress.toString()),
       abi: SlasherAbi,
@@ -171,6 +179,10 @@ export class RollupContract {
     return this.rollup.read.getTips();
   }
 
+  getTimestampForSlot(slot: bigint) {
+    return this.rollup.read.getTimestampForSlot([slot]);
+  }
+
   async getEpochNumber(blockNumber?: bigint) {
     blockNumber ??= await this.getBlockNumber();
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
@@ -191,7 +203,7 @@ export class RollupContract {
         this.rollup.read.FEE_JUICE_PORTAL(),
         this.rollup.read.REWARD_DISTRIBUTOR(),
         this.rollup.read.ASSET(),
-        this.rollup.read.STAKING_ASSET(),
+        this.rollup.read.getStakingAsset(),
       ] as const)
     ).map(EthAddress.fromString);
 

package/src/contracts/slashing_proposer.ts

@@ -10,10 +10,14 @@ import {
   getContract,
 } from 'viem';
 
-export class SlashingProposerContract {
+import type { L1Clients } from '../deploy_l1_contracts.js';
+import type { L1TxRequest } from '../l1_tx_utils.js';
+import { type IEmpireBase, encodeVote } from './empire_base.js';
+
+export class SlashingProposerContract implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, PublicClient<HttpTransport, Chain>>;
 
-  constructor(public readonly client: PublicClient<HttpTransport, Chain>, address: Hex) {
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex) {
     this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
   }
 
@@ -28,4 +32,27 @@ export class SlashingProposerContract {
   public getRoundSize() {
     return this.proposer.read.M();
   }
+
+  public computeRound(slot: bigint): Promise<bigint> {
+    return this.proposer.read.computeRound([slot]);
+  }
+
+  public async getRoundInfo(
+    rollupAddress: Hex,
+    round: bigint,
+  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
+    const roundInfo = await this.proposer.read.rounds([rollupAddress, round]);
+    return {
+      lastVote: roundInfo[0],
+      leader: roundInfo[1],
+      executed: roundInfo[2],
+    };
+  }
+
+  public createVoteRequest(payload: Hex): L1TxRequest {
+    return {
+      to: this.address.toString(),
+      data: encodeVote(payload),
+    };
+  }
 }

package/src/deploy_l1_contracts.ts

@@ -28,6 +28,8 @@ import {
   RollupLinkReferences,
   SlashFactoryAbi,
   SlashFactoryBytecode,
+  StakingLibAbi,
+  StakingLibBytecode,
   TestERC20Abi,
   TestERC20Bytecode,
   ValidatorSelectionLibAbi,
@@ -146,6 +148,10 @@ export const l1Artifacts = {
           contractAbi: ExtRollupLibAbi,
           contractBytecode: ExtRollupLibBytecode as Hex,
         },
+        StakingLib: {
+          contractAbi: StakingLibAbi,
+          contractBytecode: StakingLibBytecode as Hex,
+        },
       },
     },
   },

package/src/l1_tx_utils.ts

@@ -1,4 +1,3 @@
-import { toHex } from '@aztec/foundation/bigint-buffer';
 import { compactArray, times } from '@aztec/foundation/collection';
 import {
   type ConfigMappingsType,
@@ -23,7 +22,6 @@ import {
   type HttpTransport,
   MethodNotFoundRpcError,
   MethodNotSupportedRpcError,
-  type PublicClient,
   type StateOverride,
   type TransactionReceipt,
   type WalletClient,
@@ -32,6 +30,7 @@ import {
   hexToBytes,
 } from 'viem';
 
+import { type L1Clients } from './deploy_l1_contracts.js';
 import { formatViemError } from './utils.js';
 
 // 1_000_000_000 Gwei = 1 ETH
@@ -207,7 +206,7 @@ export class L1TxUtils {
   private interrupted = false;
 
   constructor(
-    public publicClient: PublicClient,
+    public publicClient: L1Clients['publicClient'],
     public walletClient: WalletClient<HttpTransport, Chain, Account>,
     protected readonly logger?: Logger,
     config?: Partial<L1TxUtilsConfig>,
@@ -658,32 +657,21 @@ export class L1TxUtils {
   public async tryGetErrorFromRevertedTx(
     data: Hex,
     args: {
-      args: any[];
+      args: readonly any[];
       functionName: string;
       abi: Abi;
       address: Hex;
     },
-    blobInputs?: L1BlobInputs & { maxFeePerBlobGas: bigint },
+    blobInputs: (L1BlobInputs & { maxFeePerBlobGas: bigint }) | undefined,
+    stateOverride: StateOverride = [],
   ) {
     try {
-      // NB: If this fn starts unexpectedly giving incorrect blob hash errors, it may be because the checkBlob
-      // bool is no longer at the slot below. To find the slot, run: forge inspect src/core/Rollup.sol:Rollup storage
-      const checkBlobSlot = 9n;
       await this.publicClient.simulateContract({
         ...args,
         account: this.walletClient.account,
-        stateOverride: [
-          {
-            address: args.address,
-            stateDiff: [
-              {
-                slot: toHex(checkBlobSlot, true),
-                value: toHex(0n, true),
-              },
-            ],
-          },
-        ],
+        stateOverride,
       });
+      this.logger?.trace('Simulated blob tx', { blobInputs });
       // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors.
       // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
       // See: https://github.com/wevm/viem/issues/2075
@@ -702,7 +690,9 @@ export class L1TxUtils {
             to: args.address,
             data,
           };
+      this.logger?.trace('Preparing tx', { request });
       await this.walletClient.prepareTransactionRequest(request);
+      this.logger?.trace('Prepared tx');
       return undefined;
     } catch (simulationErr: any) {
       // If we don't have a ContractFunctionExecutionError, we have a blob related error => use getContractError to get the error msg.

package/src/utils.ts

@@ -92,6 +92,30 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
+function getNestedErrorData(error: unknown): string | undefined {
+  // If nothing, bail
+  if (!error) {
+    return undefined;
+  }
+
+  // If it's an object with a `data` property, return it
+  // (Remember to check TS type-safely or cast as needed)
+  if (typeof error === 'object' && error !== null && 'data' in error) {
+    const possibleData = (error as any).data;
+    if (typeof possibleData === 'string' && possibleData.startsWith('0x')) {
+      return possibleData;
+    }
+  }
+
+  // If it has a `cause`, recurse
+  if (typeof error === 'object' && error !== null && 'cause' in error) {
+    return getNestedErrorData((error as any).cause);
+  }
+
+  // Not found
+  return undefined;
+}
+
 /**
  * Formats a Viem error into a FormattedViemError instance.
  * @param error - The error to format.
@@ -106,11 +130,12 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
 
   // First try to decode as a custom error using the ABI
   try {
-    if (error?.data) {
+    const data = getNestedErrorData(error);
+    if (data) {
       // Try to decode the error data using the ABI
       const decoded = decodeErrorResult({
         abi,
-        data: error.data as Hex,
+        data: data as Hex,
       });
       if (decoded) {
         return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages);
@@ -120,6 +145,7 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     // If it's a BaseError, try to get the custom error through ContractFunctionRevertedError
     if (error instanceof BaseError) {
       const revertError = error.walk(err => err instanceof ContractFunctionRevertedError);
+
       if (revertError instanceof ContractFunctionRevertedError) {
         let errorName = revertError.data?.errorName;
         if (!errorName) {
@@ -138,7 +164,7 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
 
   // If it's a regular Error instance, return it with its message
   if (error instanceof Error) {
-    return new FormattedViemError(error.message);
+    return error;
   }
 
   // Original formatting logic for non-custom errors