@aztec/ethereum 1.0.0 → 1.1.2

package/src/deploy_l1_contracts.ts

@@ -1,3 +1,4 @@
+import { getActiveNetworkName } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -68,7 +69,13 @@ import { foundry } from 'viem/chains';
 
 import { isAnvilTestChain } from './chain.js';
 import { createExtendedL1Client } from './client.js';
-import { DefaultEntryQueueConfig, DefaultRewardConfig, type L1ContractsConfig } from './config.js';
+import {
+  type L1ContractsConfig,
+  getEntryQueueConfig,
+  getGovernanceConfiguration,
+  getRewardBoostConfig,
+  getRewardConfig,
+} from './config.js';
 import { RegistryContract } from './contracts/registry.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { L1ContractAddresses } from './l1_contract_addresses.js';
@@ -85,6 +92,8 @@ import { ZK_PASSPORT_SCOPE, ZK_PASSPORT_SUB_SCOPE, ZK_PASSPORT_VERIFIER_ADDRESS
 
 export const DEPLOYER_ADDRESS: Hex = '0x4e59b44847b379578588920cA78FbF26c0B4956C';
 
+const networkName = getActiveNetworkName();
+
 export type Operator = {
   attester: EthAddress;
   withdrawer: EthAddress;
@@ -278,6 +287,8 @@ export const deploySharedContracts = async (
   args: DeployL1ContractsArgs,
   logger: Logger,
 ) => {
+  logger.info(`Deploying shared contracts. Network configration: ${networkName}`);
+
   const txHashes: Hex[] = [];
 
   const feeAssetAddress = await deployer.deploy(l1Artifacts.feeAsset, [
@@ -320,6 +331,7 @@ export const deploySharedContracts = async (
     stakingAssetAddress.toString(),
     governanceProposerAddress.toString(),
     gseAddress.toString(),
+    getGovernanceConfiguration(networkName),
   ]);
   logger.verbose(`Deployed Governance at ${governanceAddress}`);
 
@@ -435,19 +447,26 @@ export const deploySharedContracts = async (
       zkPassportVerifierAddress = await getZkPassportVerifierAddress(deployer, args);
       const [scope, subscope] = getZkPassportScopes(args);
 
-      stakingAssetHandlerAddress = await deployer.deploy(l1Artifacts.stakingAssetHandler, [
-        l1Client.account.address,
-        stakingAssetAddress.toString(),
-        registryAddress.toString(),
-        AMIN.toString(), // withdrawer,
-        BigInt(60 * 60 * 24), // mintInterval,
-        BigInt(10), // depositsPerMint,
-        zkPassportVerifierAddress.toString(),
-        [AMIN.toString()], // isUnhinged,
+      const stakingAssetHandlerDeployArgs = {
+        owner: l1Client.account.address,
+        stakingAsset: stakingAssetAddress.toString(),
+        registry: registryAddress.toString(),
+        withdrawer: AMIN.toString(),
+        mintInterval: BigInt(60 * 60 * 24),
+        depositsPerMint: BigInt(10),
+        depositMerkleRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        zkPassportVerifier: zkPassportVerifierAddress.toString(),
+        unhinged: [AMIN.toString()], // isUnhinged,
         // Scopes
-        scope,
-        subscope,
-        args.zkPassportArgs?.mockZkPassportVerifier ?? false, // skip Address Bind check - needed for testing without generating proofs
+        scope: scope,
+        subscope: subscope,
+        // Skip checks
+        skipBindCheck: args.zkPassportArgs?.mockZkPassportVerifier ?? false,
+        skipMerkleCheck: true, // skip merkle check - needed for testing without generating proofs
+      };
+
+      stakingAssetHandlerAddress = await deployer.deploy(l1Artifacts.stakingAssetHandler, [
+        stakingAssetHandlerDeployArgs,
       ]);
       logger.verbose(`Deployed StakingAssetHandler at ${stakingAssetHandlerAddress}`);
 
@@ -608,6 +627,8 @@ export const deployRollup = async (
     throw new Error('GSE address is required when deploying');
   }
 
+  logger.info(`Deploying rollup using network configuration: ${networkName}`);
+
   const txHashes: Hex[] = [];
 
   let epochProofVerifier = EthAddress.ZERO;
@@ -620,6 +641,11 @@ export const deployRollup = async (
     logger.verbose(`Rollup will use the mock verifier at ${epochProofVerifier}`);
   }
 
+  const rewardConfig = {
+    ...getRewardConfig(networkName),
+    rewardDistributor: addresses.rewardDistributorAddress.toString(),
+  };
+
   const rollupConfigArgs = {
     aztecSlotDuration: args.aztecSlotDuration,
     aztecEpochDuration: args.aztecEpochDuration,
@@ -628,10 +654,11 @@ export const deployRollup = async (
     slashingQuorum: args.slashingQuorum,
     slashingRoundSize: args.slashingRoundSize,
     manaTarget: args.manaTarget,
-    entryQueueFlushSizeMin: DefaultEntryQueueConfig.flushSizeMin,
-    entryQueueFlushSizeQuotient: DefaultEntryQueueConfig.flushSizeQuotient,
     provingCostPerMana: args.provingCostPerMana,
-    rewardConfig: DefaultRewardConfig,
+    rewardConfig: rewardConfig,
+    rewardBoostConfig: getRewardBoostConfig(networkName),
+    stakingQueueConfig: getEntryQueueConfig(networkName),
+    exitDelaySeconds: args.exitDelaySeconds,
   };
   const genesisStateArgs = {
     vkTreeRoot: args.vkTreeRoot.toString(),
@@ -642,7 +669,6 @@ export const deployRollup = async (
 
   const rollupArgs = [
     addresses.feeJuiceAddress.toString(),
-    addresses.rewardDistributorAddress.toString(),
     addresses.stakingAssetAddress.toString(),
     addresses.gseAddress.toString(),
     epochProofVerifier.toString(),
@@ -1221,9 +1247,10 @@ export async function deployL1Contract(
   }
 
   if (maybeSalt) {
+    logger?.info(`Deploying contract with salt ${maybeSalt}`);
     const { address, paddedSalt: salt, calldata } = getExpectedAddress(abi, bytecode, args, maybeSalt);
     resultingAddress = address;
-    const existing = await extendedClient.getBytecode({ address: resultingAddress });
+    const existing = await extendedClient.getCode({ address: resultingAddress });
     if (existing === undefined || existing === '0x') {
       const res = await l1TxUtils.sendTransaction({
         to: DEPLOYER_ADDRESS,

package/src/l1_tx_utils.ts

@@ -2,6 +2,7 @@ import { compactArray, times } from '@aztec/foundation/collection';
 import {
   type ConfigMappingsType,
   bigintConfigHelper,
+  booleanConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
@@ -11,6 +12,7 @@ import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 
+import pickBy from 'lodash.pickby';
 import {
   type Abi,
   type Account,
@@ -99,6 +101,10 @@ export interface L1TxUtilsConfig {
    * First attempt is done at 1s, second at 2s, third at 3s, etc.
    */
   txPropagationMaxQueryAttempts?: number;
+  /**
+   * Whether to attempt to cancel a tx if it's not mined after txTimeoutMs
+   */
+  cancelTxOnTimeout?: boolean;
 }
 
 export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
@@ -145,18 +151,23 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   stallTimeMs: {
     description: 'How long before considering tx stalled',
     env: 'L1_TX_MONITOR_STALL_TIME_MS',
-    ...numberConfigHelper(45_000),
+    ...numberConfigHelper(24_000), // 24s, 2 ethereum slots
   },
   txTimeoutMs: {
     description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
     env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
-    ...numberConfigHelper(300_000), // 5 mins
+    ...numberConfigHelper(120_000), // 2 mins
   },
   txPropagationMaxQueryAttempts: {
     description: 'How many attempts will be done to get a tx after it was sent',
     env: 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS',
     ...numberConfigHelper(3),
   },
+  cancelTxOnTimeout: {
+    description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
+    env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
+    ...booleanConfigHelper(true),
+  },
 };
 
 export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(l1TxUtilsConfigMappings);
@@ -480,7 +491,7 @@ export class ReadOnlyL1TxUtils {
   ) {
     try {
       const result = await this.client.simulateBlocks({
-        validation: true,
+        validation: false,
         blocks: [
           {
             blockOverrides,
@@ -522,7 +533,9 @@ export class ReadOnlyL1TxUtils {
   public bumpGasLimit(gasLimit: bigint, _gasConfig?: L1TxUtilsConfig): bigint {
     const gasConfig = { ...this.config, ..._gasConfig };
     const bumpedGasLimit = gasLimit + (gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00)) / 100_00n;
-    this.logger?.debug('Bumping gas limit', { gasLimit, gasConfig, bumpedGasLimit });
+
+    const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
+    this.logger?.debug('Bumping gas limit', { gasLimit, gasConfig: cleanGasConfig, bumpedGasLimit });
     return bumpedGasLimit;
   }
 }
@@ -600,10 +613,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
           maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
         });
       }
+      const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
       this.logger?.verbose(`Sent L1 transaction ${txHash}`, {
         gasLimit,
         maxFeePerGas: formatGwei(gasPrice.maxFeePerGas),
         maxPriorityFeePerGas: formatGwei(gasPrice.maxPriorityFeePerGas),
+        gasConfig: cleanGasConfig,
         ...(gasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(gasPrice.maxFeePerBlobGas) }),
       });
 
@@ -748,7 +763,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             },
           );
 
-          currentTxHash = await this.client.sendTransaction({
+          const newHash = await this.client.sendTransaction({
             ...request,
             ...blobInputs,
             nonce,
@@ -757,6 +772,17 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
             maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
           });
 
+          const cleanGasConfig = pickBy(gasConfig, (_, key) => key in l1TxUtilsConfigMappings);
+          this.logger?.verbose(`Sent L1 speed-up tx ${newHash}, replacing ${currentTxHash}`, {
+            gasLimit: params.gasLimit,
+            maxFeePerGas: formatGwei(newGasPrice.maxFeePerGas),
+            maxPriorityFeePerGas: formatGwei(newGasPrice.maxPriorityFeePerGas),
+            gasConfig: cleanGasConfig,
+            ...(newGasPrice.maxFeePerBlobGas && { maxFeePerBlobGas: formatGwei(newGasPrice.maxFeePerBlobGas) }),
+          });
+
+          currentTxHash = newHash;
+
           txHashes.add(currentTxHash);
           lastAttemptSent = Date.now();
         }
@@ -773,18 +799,14 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       txTimedOut = isTimedOut();
     }
 
-    if (!isCancelTx) {
+    if (!isCancelTx && gasConfig.cancelTxOnTimeout) {
       // Fire cancellation without awaiting to avoid blocking the main thread
-      this.attemptTxCancellation(nonce, isBlobTx, lastGasPrice, attempts)
-        .then(cancelTxHash => {
-          this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
-        })
-        .catch(err => {
-          const viemError = formatViemError(err);
-          this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
-            metaMessages: viemError.metaMessages,
-          });
+      this.attemptTxCancellation(currentTxHash, nonce, isBlobTx, lastGasPrice, attempts).catch(err => {
+        const viemError = formatViemError(err);
+        this.logger?.error(`Failed to send cancellation for timed out tx ${currentTxHash}:`, viemError.message, {
+          metaMessages: viemError.metaMessages,
         });
+      });
 
       this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
         txHash: currentTxHash,
@@ -812,11 +834,12 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
 
   public override async simulate(
     request: L1TxRequest & { gas?: bigint; from?: Hex },
-    blockOverrides: BlockOverrides<bigint, number> = {},
+    _blockOverrides: BlockOverrides<bigint, number> = {},
     stateOverrides: StateOverride = [],
     abi: Abi = RollupAbi,
-    _gasConfig?: L1TxUtilsConfig & { fallbackGasEstimate?: bigint },
+    _gasConfig?: L1TxUtilsConfig & { fallbackGasEstimate?: bigint; ignoreBlockGasLimit?: boolean },
   ): Promise<{ gasUsed: bigint; result: `0x${string}` }> {
+    const blockOverrides = { ..._blockOverrides };
     const gasConfig = { ...this.config, ..._gasConfig };
     const gasPrice = await this.getGasPrice(gasConfig, false);
 
@@ -829,6 +852,11 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       gas: request.gas ?? LARGE_GAS_LIMIT,
     };
 
+    if (!request.gas && !gasConfig.ignoreBlockGasLimit) {
+      // LARGE_GAS_LIMIT is set as call.gas, increase block gasLimit
+      blockOverrides.gasLimit = LARGE_GAS_LIMIT * 2n;
+    }
+
     return this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
   }
 
@@ -839,7 +867,13 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    * @param attempts - The number of attempts to cancel the transaction
    * @returns The hash of the cancellation transaction
    */
-  protected async attemptTxCancellation(nonce: number, isBlobTx = false, previousGasPrice?: GasPrice, attempts = 0) {
+  protected async attemptTxCancellation(
+    currentTxHash: Hex,
+    nonce: number,
+    isBlobTx = false,
+    previousGasPrice?: GasPrice,
+    attempts = 0,
+  ) {
     if (isBlobTx) {
       throw new Error('Cannot cancel blob transactions, please use L1TxUtilsWithBlobsClass');
     }
@@ -858,7 +892,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       previousGasPrice,
     );
 
-    this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
+    this.logger?.debug(`Attempting to cancel L1 transaction ${currentTxHash} with nonce ${nonce}`, {
       maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
       maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
     });
@@ -875,6 +909,9 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
       maxFeePerGas: cancelGasPrice.maxFeePerGas,
       maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
     });
+
+    this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, { nonce });
+
     const receipt = await this.monitorTransaction(
       request,
       cancelTxHash,

package/src/l1_tx_utils_with_blobs.ts

@@ -1,6 +1,6 @@
 import { Blob } from '@aztec/blob-lib';
 
-import { formatGwei } from 'viem';
+import { type Hex, formatGwei } from 'viem';
 
 import { type GasPrice, L1TxUtils } from './l1_tx_utils.js';
 
@@ -12,7 +12,13 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
    * @param attempts - The number of attempts to cancel the transaction
    * @returns The hash of the cancellation transaction
    */
-  override async attemptTxCancellation(nonce: number, isBlobTx = false, previousGasPrice?: GasPrice, attempts = 0) {
+  override async attemptTxCancellation(
+    currentTxHash: Hex,
+    nonce: number,
+    isBlobTx = false,
+    previousGasPrice?: GasPrice,
+    attempts = 0,
+  ) {
     const account = this.client.account;
 
     // Get gas price with higher priority fee for cancellation
@@ -27,9 +33,11 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
       previousGasPrice,
     );
 
-    this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
+    this.logger?.debug(`Attempting to cancel blob L1 transaction ${currentTxHash} with nonce ${nonce}`, {
       maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
       maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
+      maxFeePerBlobGas:
+        cancelGasPrice.maxFeePerBlobGas === undefined ? undefined : formatGwei(cancelGasPrice.maxFeePerBlobGas),
     });
     const request = {
       to: account.address,
@@ -71,6 +79,9 @@ export class L1TxUtilsWithBlobs extends L1TxUtils {
         maxFeePerGas: cancelGasPrice.maxFeePerGas,
         maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
       });
+
+      this.logger?.debug(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`);
+
       const receipt = await this.monitorTransaction(
         request,
         cancelTxHash,

package/src/queries.ts

@@ -45,6 +45,7 @@ export async function getL1ContractsConfig(
     provingCostPerMana,
     rollupVersion,
     genesisArchiveTreeRoot,
+    exitDelay,
   ] = await Promise.all([
     rollup.getL1StartBlock(),
     rollup.getL1GenesisTime(),
@@ -62,6 +63,7 @@ export async function getL1ContractsConfig(
     rollup.getProvingCostPerMana(),
     rollup.getVersion(),
     rollup.getGenesisArchiveTreeRoot(),
+    rollup.getExitDelay(),
   ] as const);
 
   return {
@@ -81,6 +83,7 @@ export async function getL1ContractsConfig(
     provingCostPerMana: provingCostPerMana,
     rollupVersion: Number(rollupVersion),
     genesisArchiveTreeRoot,
+    exitDelaySeconds: Number(exitDelay),
   };
 }
 

package/src/test/start_anvil.ts

@@ -11,9 +11,11 @@ export async function startAnvil(
   opts: {
     port?: number;
     l1BlockTime?: number;
+    captureMethodCalls?: boolean;
   } = {},
-): Promise<{ anvil: Anvil; rpcUrl: string; stop: () => Promise<void> }> {
+): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
   const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+  const methodCalls = opts.captureMethodCalls ? ([] as string[]) : undefined;
 
   let port: number | undefined;
 
@@ -31,13 +33,13 @@ export async function startAnvil(
 
       // Listen to the anvil output to get the port.
       const removeHandler = anvil.on('message', (message: string) => {
+        methodCalls?.push(...(message.match(/eth_[^\s]+/g) || []));
         if (port === undefined && message.includes('Listening on')) {
           port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)![2]);
         }
       });
       await anvil.start();
       removeHandler();
-
       return anvil;
     },
     'Start anvil',
@@ -50,5 +52,5 @@ export async function startAnvil(
 
   // Monkeypatch the anvil instance to include the actually assigned port
   // Object.defineProperty(anvil, 'port', { value: port, writable: false });
-  return { anvil, stop: () => anvil.stop(), rpcUrl: `http://127.0.0.1:${port}` };
+  return { anvil, methodCalls, stop: () => anvil.stop(), rpcUrl: `http://127.0.0.1:${port}` };
 }