@aztec/ethereum 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/src/config.ts

@@ -1,15 +1,17 @@
 import {
   type ConfigMappingsType,
-  // type NetworkNames,
   bigintConfigHelper,
   booleanConfigHelper,
   enumConfigHelper,
   getConfigFromMappings,
+  getDefaultConfig,
   numberConfigHelper,
+  omitConfigMappings,
   optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
+import { l1ContractsDefaultEnv } from './generated/l1-contracts-defaults.js';
 import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './l1_tx_utils/config.js';
 
 export type GenesisStateConfig = {
@@ -68,124 +70,108 @@ export type L1ContractsConfig = {
   governanceProposerQuorum?: number;
   /** Governance proposing round size */
   governanceProposerRoundSize: number;
+  /** Governance voting duration in seconds (only for local/devnet/next-net, default 3600) */
+  governanceVotingDuration?: number;
   /** The mana target for the rollup */
   manaTarget: bigint;
   /** The proving cost per mana */
   provingCostPerMana: bigint;
+  /** The initial ETH per fee asset price (with 1e12 precision) */
+  initialEthPerFeeAsset: bigint;
   /** The number of seconds to wait for an exit */
   exitDelaySeconds: number;
 } & L1TxUtilsConfig;
 
-export const DefaultL1ContractsConfig = {
-  ethereumSlotDuration: 12,
-  aztecSlotDuration: 36,
-  aztecEpochDuration: 32,
-  aztecTargetCommitteeSize: 48,
-  lagInEpochsForValidatorSet: 2,
-  lagInEpochsForRandao: 2, // For PROD, this value should be > lagInEpochsForValidatorSet
-  inboxLag: 1, // Default inbox lag to prevent sequencer DOS attacks
-  aztecProofSubmissionEpochs: 1, // you have a full epoch to submit a proof after the epoch to prove ends
-  activationThreshold: 100n * 10n ** 18n,
-  ejectionThreshold: 50n * 10n ** 18n,
-  localEjectionThreshold: 98n * 10n ** 18n,
-  slashAmountSmall: 10n * 10n ** 18n,
-  slashAmountMedium: 20n * 10n ** 18n,
-  slashAmountLarge: 50n * 10n ** 18n,
-  slashingRoundSizeInEpochs: 4,
-  slashingLifetimeInRounds: 5,
-  slashingExecutionDelayInRounds: 0, // round N may be submitted in round N + 1
-  slashingVetoer: EthAddress.ZERO,
-  governanceProposerRoundSize: 300,
-  manaTarget: BigInt(100e6),
-  provingCostPerMana: BigInt(100),
-  exitDelaySeconds: 2 * 24 * 60 * 60,
-  slasherFlavor: 'tally' as const,
-  slashingOffsetInRounds: 2,
-  slashingDisableDuration: 5 * 24 * 60 * 60, // 5 days in seconds
-} satisfies L1ContractsConfig;
-
+/**
+ * Config mappings for L1ContractsConfig.
+ * Default values come from generated l1-contracts-defaults.json (source: defaults.yml).
+ * Real deployments use forge scripts which require explicit env vars (vm.envUint).
+ */
 export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> = {
   ethereumSlotDuration: {
     env: 'ETHEREUM_SLOT_DURATION',
     description: 'How many seconds an L1 slot lasts.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.ethereumSlotDuration),
+    ...numberConfigHelper(l1ContractsDefaultEnv.ETHEREUM_SLOT_DURATION),
   },
   aztecSlotDuration: {
     env: 'AZTEC_SLOT_DURATION',
     description: 'How many seconds an L2 slots lasts (must be multiple of ethereum slot duration).',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecSlotDuration),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLOT_DURATION),
   },
   aztecEpochDuration: {
     env: 'AZTEC_EPOCH_DURATION',
-    description: `How many L2 slots an epoch lasts (maximum AZTEC_MAX_EPOCH_DURATION).`,
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecEpochDuration),
+    description: `How many L2 slots an epoch lasts (maximum MAX_CHECKPOINTS_PER_EPOCH).`,
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_EPOCH_DURATION),
   },
   aztecTargetCommitteeSize: {
     env: 'AZTEC_TARGET_COMMITTEE_SIZE',
     description: 'The target validator committee size.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecTargetCommitteeSize),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_TARGET_COMMITTEE_SIZE),
   },
   lagInEpochsForValidatorSet: {
     env: 'AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET',
     description: 'The number of epochs to lag behind the current epoch for validator selection.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.lagInEpochsForValidatorSet),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET),
   },
   lagInEpochsForRandao: {
     env: 'AZTEC_LAG_IN_EPOCHS_FOR_RANDAO',
     description: 'The number of epochs to lag behind the current epoch for randao selection.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.lagInEpochsForRandao),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_LAG_IN_EPOCHS_FOR_RANDAO),
   },
   inboxLag: {
     env: 'AZTEC_INBOX_LAG',
     description: 'The number of checkpoints to lag in the inbox (prevents sequencer DOS attacks).',
-    ...numberConfigHelper(DefaultL1ContractsConfig.inboxLag),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_INBOX_LAG),
   },
   aztecProofSubmissionEpochs: {
     env: 'AZTEC_PROOF_SUBMISSION_EPOCHS',
     description: 'The number of epochs after an epoch ends that proofs are still accepted.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecProofSubmissionEpochs),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_PROOF_SUBMISSION_EPOCHS),
   },
   activationThreshold: {
     env: 'AZTEC_ACTIVATION_THRESHOLD',
     description: 'The deposit amount for a validator',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.activationThreshold),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_ACTIVATION_THRESHOLD)),
   },
   ejectionThreshold: {
     env: 'AZTEC_EJECTION_THRESHOLD',
     description: 'The minimum stake for a validator.',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.ejectionThreshold),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_EJECTION_THRESHOLD)),
   },
   localEjectionThreshold: {
     env: 'AZTEC_LOCAL_EJECTION_THRESHOLD',
     description:
       'The local ejection threshold for a validator. Stricter than ejectionThreshold but local to a specific rollup',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.localEjectionThreshold),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_LOCAL_EJECTION_THRESHOLD)),
   },
   slashingOffsetInRounds: {
     env: 'AZTEC_SLASHING_OFFSET_IN_ROUNDS',
     description:
       'How many slashing rounds back we slash (ie when slashing in round N, we slash for offenses committed during epochs of round N-offset)',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingOffsetInRounds),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_OFFSET_IN_ROUNDS),
   },
   slasherFlavor: {
     env: 'AZTEC_SLASHER_FLAVOR',
     description: 'Type of slasher proposer (empire, tally, or none)',
-    ...enumConfigHelper(['empire', 'tally', 'none'] as const, DefaultL1ContractsConfig.slasherFlavor),
+    ...enumConfigHelper(
+      ['empire', 'tally', 'none'] as const,
+      l1ContractsDefaultEnv.AZTEC_SLASHER_FLAVOR as 'empire' | 'tally' | 'none',
+    ),
   },
   slashAmountSmall: {
     env: 'AZTEC_SLASH_AMOUNT_SMALL',
     description: 'Small slashing amount for light offenses',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.slashAmountSmall),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_SMALL)),
   },
   slashAmountMedium: {
     env: 'AZTEC_SLASH_AMOUNT_MEDIUM',
     description: 'Medium slashing amount for moderate offenses',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.slashAmountMedium),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_MEDIUM)),
   },
   slashAmountLarge: {
     env: 'AZTEC_SLASH_AMOUNT_LARGE',
     description: 'Large slashing amount for severe offenses',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.slashAmountLarge),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_LARGE)),
   },
   slashingQuorum: {
     env: 'AZTEC_SLASHING_QUORUM',
@@ -195,28 +181,28 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
   slashingRoundSizeInEpochs: {
     env: 'AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS',
     description: 'The slashing round size',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingRoundSizeInEpochs),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS),
   },
   slashingLifetimeInRounds: {
     env: 'AZTEC_SLASHING_LIFETIME_IN_ROUNDS',
     description: 'The slashing lifetime in rounds',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingLifetimeInRounds),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_LIFETIME_IN_ROUNDS),
   },
   slashingExecutionDelayInRounds: {
     env: 'AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS',
     description: 'The slashing execution delay in rounds',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingExecutionDelayInRounds),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS),
   },
   slashingVetoer: {
     env: 'AZTEC_SLASHING_VETOER',
     description: 'The slashing vetoer',
     parseEnv: (val: string) => EthAddress.fromString(val),
-    defaultValue: DefaultL1ContractsConfig.slashingVetoer,
+    defaultValue: EthAddress.fromString(l1ContractsDefaultEnv.AZTEC_SLASHING_VETOER),
   },
   slashingDisableDuration: {
     env: 'AZTEC_SLASHING_DISABLE_DURATION',
     description: 'How long slashing can be disabled for in seconds when vetoer disables it',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingDisableDuration),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_DISABLE_DURATION),
   },
   governanceProposerQuorum: {
     env: 'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
@@ -226,26 +212,42 @@ export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> =
   governanceProposerRoundSize: {
     env: 'AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE',
     description: 'The governance proposing round size',
-    ...numberConfigHelper(DefaultL1ContractsConfig.governanceProposerRoundSize),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE),
+  },
+  governanceVotingDuration: {
+    env: 'AZTEC_GOVERNANCE_VOTING_DURATION',
+    description: 'Governance voting duration in seconds (only for local/devnet/next-net)',
+    ...numberConfigHelper(3600), // 1 hour default, not in generated defaults as it's deployment-time only
   },
   manaTarget: {
     env: 'AZTEC_MANA_TARGET',
     description: 'The mana target for the rollup',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.manaTarget),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_MANA_TARGET)),
   },
   provingCostPerMana: {
     env: 'AZTEC_PROVING_COST_PER_MANA',
     description: 'The proving cost per mana',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.provingCostPerMana),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_PROVING_COST_PER_MANA)),
+  },
+  initialEthPerFeeAsset: {
+    env: 'AZTEC_INITIAL_ETH_PER_FEE_ASSET',
+    description: 'The initial ETH per fee asset price (with 1e12 precision)',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_INITIAL_ETH_PER_FEE_ASSET)),
   },
   exitDelaySeconds: {
     env: 'AZTEC_EXIT_DELAY_SECONDS',
     description: 'The delay before a validator can exit the set',
-    ...numberConfigHelper(DefaultL1ContractsConfig.exitDelaySeconds),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_EXIT_DELAY_SECONDS),
   },
-  ...l1TxUtilsConfigMappings,
+  ...omitConfigMappings(l1TxUtilsConfigMappings, ['ethereumSlotDuration']),
 };
 
+/**
+ * Default L1 contracts configuration derived from l1ContractsConfigMappings.
+ * Source of truth: spartan/environments/defaults.yml -> defaults.l1-contracts
+ */
+export const DefaultL1ContractsConfig = getDefaultConfig(l1ContractsConfigMappings);
+
 export const genesisStateConfigMappings: ConfigMappingsType<GenesisStateConfig> = {
   testAccounts: {
     env: 'TEST_ACCOUNTS',

package/src/contracts/README.md

@@ -0,0 +1,157 @@
+# L1 Contract Wrappers
+
+This folder contains TypeScript wrappers for L1 contracts defined in `l1-contracts/`. These wrappers are used by the node client to interact with the rollup and related contracts on Ethereum.
+
+## Purpose
+
+The goal of wrapping is to shield consumers from L1-specific and viem-specific details. Clients using these wrappers interact with domain types and branded types native to the Aztec codebase, without needing to understand viem's ABI type system or deal with raw types like `Hex` and `bigint`.
+
+## Type Safety
+
+### Explicit Return Types
+
+Every function in the contract wrappers must declare its return type explicitly. This is critical because viem's type inference over ABI types is slow and significantly impacts IDE performance.
+
+```typescript
+// Good: Explicit return type
+async getSlotNumber(): Promise<SlotNumber> {
+  return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+}
+
+// Bad: Inferred return type (slow)
+async getSlotNumber() {
+  return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+}
+```
+
+### Branded and Domain Types
+
+Use branded types and domain-specific types instead of viem's autogenerated types for both arguments and return values:
+
+- `CheckpointNumber`, `EpochNumber`, `SlotNumber` instead of `bigint`
+- `EthAddress` instead of `` `0x${string}` `` or `Hex`
+- `Fr`, `Buffer32` instead of `Hex` for hashes and field elements
+- Custom domain types (e.g., `CheckpointLog`, `AttesterView`) instead of raw tuples
+
+Type conversions happen inside wrapper methods, not at the call site:
+
+```typescript
+async getCheckpoint(checkpointNumber: CheckpointNumber): Promise<CheckpointLog> {
+  const result = await this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
+  return {
+    archive: Fr.fromString(result.archive),
+    headerHash: Buffer32.fromString(result.headerHash),
+    blockCount: result.blockCount,
+  };
+}
+```
+
+## Wrapper Pattern
+
+### Basic Structure
+
+Each wrapper follows a consistent structure:
+
+```typescript
+export class FooContract {
+  private readonly foo: GetContractReturnType<typeof FooAbi, ViemClient>;
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.foo = getContract({ address, abi: FooAbi, client });
+  }
+
+  public get address(): Hex {
+    return this.foo.address;
+  }
+
+  public getContract(): GetContractReturnType<typeof FooAbi, ViemClient> {
+    return this.foo;
+  }
+}
+```
+
+The raw contract is exposed via `getContract()` for cases where direct access is needed, but most consumers should use the typed wrapper methods. Relying on `getContract()` is a code smell and should be avoided.
+
+### Static Factory Methods
+
+Wrappers may provide static factory methods for common initialization patterns:
+
+- `getFromConfig(config)` - construct from configuration object
+- `getFromL1ContractsValues(deployResult)` - construct from deployment result
+
+### Wallet Assertions
+
+For write operations that require a wallet, use an assertion helper:
+
+```typescript
+private assertWallet(): GetContractReturnType<typeof FooAbi, ExtendedViemWalletClient> {
+  if (!isExtendedClient(this.client)) {
+    throw new Error('Wallet client is required for this operation');
+  }
+  return this.foo as GetContractReturnType<typeof FooAbi, ExtendedViemWalletClient>;
+}
+```
+
+## Event Handling
+
+### Event Log Types
+
+Event logs are wrapped in `L1EventLog<T>` to include L1 block context:
+
+```typescript
+type L1EventLog<T> = {
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+  l1TransactionHash: Hex;
+  args: T;
+};
+```
+
+### Event Fetching
+
+Methods that fetch events convert viem's raw logs to domain types:
+
+```typescript
+async getCheckpointProposedEvents(fromBlock: bigint, toBlock: bigint): Promise<CheckpointProposedLog[]> {
+  const logs = await this.rollup.getEvents.CheckpointProposed({}, { fromBlock, toBlock });
+  return logs.map(log => ({
+    l1BlockNumber: log.blockNumber!,
+    l1BlockHash: Buffer32.fromString(log.blockHash!),
+    l1TransactionHash: log.transactionHash!,
+    args: {
+      checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
+      // ... convert other fields
+    },
+  }));
+}
+```
+
+### Event Listeners
+
+For reactive event handling, wrapper methods convert arguments before invoking callbacks:
+
+```typescript
+public listenToCheckpointInvalidated(
+  callback: (args: { checkpointNumber: CheckpointNumber }) => unknown,
+): WatchContractEventReturnType {
+  return this.rollup.watchEvent.CheckpointInvalidated({}, {
+    onLogs: logs => {
+      for (const log of logs) {
+        if (log.args.checkpointNumber !== undefined) {
+          callback({ checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber) });
+        }
+      }
+    },
+  });
+}
+```
+
+## Error Handling
+
+Custom error classes in `errors.ts` extend `Error` and set `this.name` for proper error identification. Include relevant context as public readonly properties.

package/src/contracts/empire_base.ts

@@ -22,6 +22,8 @@ export interface IEmpireBase {
     signerAddress: Hex,
     signer: (msg: TypedDataDefinition) => Promise<Hex>,
   ): Promise<L1TxRequest>;
+  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
+  hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean>;
 }
 
 export function encodeSignal(payload: Hex): Hex {

package/src/contracts/empire_slashing_proposer.ts

@@ -6,7 +6,6 @@ import { EmpireSlashingProposerAbi } from '@aztec/l1-artifacts/EmpireSlashingPro
 
 import EventEmitter from 'events';
 import {
-  type EncodeFunctionDataParameters,
   type GetContractReturnType,
   type Hex,
   type Log,
@@ -100,6 +99,7 @@ export class EmpireSlashingProposerContract extends EventEmitter implements IEmp
   public createSignalRequest(payload: Hex): L1TxRequest {
     return {
       to: this.address.toString(),
+      abi: EmpireSlashingProposerAbi,
       data: encodeSignal(payload),
     };
   }
@@ -121,10 +121,17 @@ export class EmpireSlashingProposerContract extends EventEmitter implements IEmp
     );
     return {
       to: this.address.toString(),
+      abi: EmpireSlashingProposerAbi,
       data: encodeSignalWithSignature(payload, signature),
     };
   }
 
+  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
+  public async hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean> {
+    const events = await this.proposer.getEvents.PayloadSubmitted({ payload }, { fromBlock, strict: true });
+    return events.length > 0;
+  }
+
   public listenToSubmittablePayloads(callback: (args: { payload: `0x${string}`; round: bigint }) => unknown) {
     return this.proposer.watchEvent.PayloadSubmittable(
       {},
@@ -180,6 +187,7 @@ export class EmpireSlashingProposerContract extends EventEmitter implements IEmp
   public buildExecuteRoundRequest(round: bigint): L1TxRequest {
     return {
       to: this.address.toString(),
+      abi: EmpireSlashingProposerAbi,
       data: encodeFunctionData({
         abi: EmpireSlashingProposerAbi,
         functionName: 'submitRoundWinner',
@@ -222,24 +230,13 @@ export class EmpireSlashingProposerContract extends EventEmitter implements IEmp
     if (typeof round === 'number') {
       round = BigInt(round);
     }
-    const args: EncodeFunctionDataParameters<typeof EmpireSlashingProposerAbi, 'submitRoundWinner'> = {
-      abi: EmpireSlashingProposerAbi,
-      functionName: 'submitRoundWinner',
-      args: [round],
-    };
-    const data = encodeFunctionData(args);
+    const request = this.buildExecuteRoundRequest(round);
     const response = await txUtils
-      .sendAndMonitorTransaction(
-        {
-          to: this.address.toString(),
-          data,
-        },
-        {
-          // Gas estimation is way off for this, likely because we are creating the contract/selector to call
-          // for the actual slashing dynamically.
-          gasLimitBufferPercentage: 50, // +50% gas
-        },
-      )
+      .sendAndMonitorTransaction(request, {
+        // Gas estimation is way off for this, likely because we are creating the contract/selector to call
+        // for the actual slashing dynamically.
+        gasLimitBufferPercentage: 50, // +50% gas
+      })
       .catch(err => {
         if (err instanceof FormattedViemError && err.message.includes('ProposalAlreadyExecuted')) {
           throw new ProposalAlreadyExecutedError(round);
@@ -248,15 +245,13 @@ export class EmpireSlashingProposerContract extends EventEmitter implements IEmp
       });
 
     if (response.receipt.status === 'reverted') {
-      const error = await txUtils.tryGetErrorFromRevertedTx(
-        data,
-        {
-          ...args,
-          address: this.address.toString(),
-        },
-        undefined,
-        [],
-      );
+      const args = {
+        abi: EmpireSlashingProposerAbi,
+        functionName: 'submitRoundWinner' as const,
+        args: [round] as const,
+        address: this.address.toString(),
+      };
+      const error = await txUtils.tryGetErrorFromRevertedTx(request.data!, args, undefined, []);
       if (error?.includes('ProposalAlreadyExecuted')) {
         throw new ProposalAlreadyExecutedError(round);
       }

package/src/contracts/fee_asset_handler.ts

@@ -4,13 +4,14 @@ import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts/FeeAssetHandlerAbi';
 import { type Hex, encodeFunctionData, getContract } from 'viem';
 
 import type { L1TxUtils } from '../l1_tx_utils/index.js';
+import type { ViemClient } from '../types.js';
 
 export class FeeAssetHandlerContract {
   public address: EthAddress;
 
   constructor(
+    public readonly client: ViemClient,
     address: Hex | EthAddress,
-    public readonly txUtils: L1TxUtils,
   ) {
     if (address instanceof EthAddress) {
       address = address.toString();
@@ -22,7 +23,7 @@ export class FeeAssetHandlerContract {
     const contract = getContract({
       abi: FeeAssetHandlerAbi,
       address: this.address.toString(),
-      client: this.txUtils.client,
+      client: this.client,
     });
     return EthAddress.fromString(await contract.read.owner());
   }
@@ -31,17 +32,18 @@ export class FeeAssetHandlerContract {
     const contract = getContract({
       abi: FeeAssetHandlerAbi,
       address: this.address.toString(),
-      client: this.txUtils.client,
+      client: this.client,
     });
     return contract.read.mintAmount();
   }
 
-  public mint(recipient: Hex | EthAddress) {
+  public mint(txUtils: L1TxUtils, recipient: Hex | EthAddress) {
     if (recipient instanceof EthAddress) {
       recipient = recipient.toString();
     }
-    return this.txUtils.sendAndMonitorTransaction({
+    return txUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
+      abi: FeeAssetHandlerAbi,
       data: encodeFunctionData({
         abi: FeeAssetHandlerAbi,
         functionName: 'mint',
@@ -50,9 +52,10 @@ export class FeeAssetHandlerContract {
     });
   }
 
-  public setMintAmount(amount: bigint) {
-    return this.txUtils.sendAndMonitorTransaction({
+  public setMintAmount(txUtils: L1TxUtils, amount: bigint) {
+    return txUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
+      abi: FeeAssetHandlerAbi,
       data: encodeFunctionData({
         abi: FeeAssetHandlerAbi,
         functionName: 'setMintAmount',