@aztec/ethereum 0.80.0 → 0.82.0

package/src/contracts/rollup.ts

@@ -73,6 +73,10 @@ export class RollupContract {
     return this.rollup.address;
   }
 
+  getContract(): GetContractReturnType<typeof RollupAbi, ViemPublicClient> {
+    return this.rollup;
+  }
+
   @memoize
   public async getSlashingProposer() {
     const slasherAddress = await this.rollup.read.getSlasher();
@@ -116,8 +120,32 @@ export class RollupContract {
     return this.rollup.read.getMinimumStake();
   }
 
+  @memoize
+  getManaTarget() {
+    return this.rollup.read.getManaTarget();
+  }
+
+  @memoize
+  getProvingCostPerMana() {
+    return this.rollup.read.getProvingCostPerManaInEth();
+  }
+
+  @memoize
+  getProvingCostPerManaInFeeAsset() {
+    return this.rollup.read.getProvingCostPerManaInFeeAsset();
+  }
+
+  @memoize
+  getManaLimit() {
+    return this.rollup.read.getManaLimit();
+  }
+
+  getSlasher() {
+    return this.rollup.read.getSlasher();
+  }
+
   public async getSlashingProposerAddress() {
-    const slasherAddress = await this.rollup.read.getSlasher();
+    const slasherAddress = await this.getSlasher();
     const slasher = getContract({
       address: getAddress(slasherAddress.toString()),
       abi: SlasherAbi,
@@ -138,8 +166,15 @@ export class RollupContract {
     return this.rollup.read.getCurrentSlot();
   }
 
-  getCommitteeAt(timestamp: bigint) {
-    return this.rollup.read.getCommitteeAt([timestamp]);
+  async getCommitteeAt(timestamp: bigint) {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getCommitteeAt',
+      args: [timestamp],
+    });
+
+    return result;
   }
 
   getSampleSeedAt(timestamp: bigint) {
@@ -150,16 +185,37 @@ export class RollupContract {
     return this.rollup.read.getCurrentSampleSeed();
   }
 
-  getCurrentEpochCommittee() {
-    return this.rollup.read.getCurrentEpochCommittee();
+  async getCurrentEpochCommittee() {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getCurrentEpochCommittee',
+      args: [],
+    });
+
+    return result;
   }
 
-  getCurrentProposer() {
-    return this.rollup.read.getCurrentProposer();
+  async getCurrentProposer() {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getCurrentProposer',
+      args: [],
+    });
+
+    return result;
   }
 
-  getProposerAt(timestamp: bigint) {
-    return this.rollup.read.getProposerAt([timestamp]);
+  async getProposerAt(timestamp: bigint) {
+    const { result } = await this.client.simulateContract({
+      address: this.address,
+      abi: RollupAbi,
+      functionName: 'getProposerAt',
+      args: [timestamp],
+    });
+
+    return result;
   }
 
   getBlock(blockNumber: bigint) {
@@ -234,7 +290,13 @@ export class RollupContract {
     account: `0x${string}` | Account,
   ): Promise<void> {
     try {
-      await this.rollup.read.validateHeader(args, { account });
+      await this.client.simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'validateHeader',
+        args,
+        account,
+      });
     } catch (error: unknown) {
       throw formatViemError(error);
     }
@@ -259,10 +321,16 @@ export class RollupContract {
     }
     const timeOfNextL1Slot = (await this.client.getBlock()).timestamp + slotDuration;
     try {
-      const [slot, blockNumber] = await this.rollup.read.canProposeAtTime(
-        [timeOfNextL1Slot, `0x${archive.toString('hex')}`],
-        { account },
-      );
+      const {
+        result: [slot, blockNumber],
+      } = await this.client.simulateContract({
+        address: this.address,
+        abi: RollupAbi,
+        functionName: 'canProposeAtTime',
+        args: [timeOfNextL1Slot, `0x${archive.toString('hex')}`],
+        account,
+      });
+
       return [slot, blockNumber];
     } catch (err: unknown) {
       throw formatViemError(err);
@@ -270,7 +338,82 @@ export class RollupContract {
   }
 
   /** 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: EthAddress) {
-    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover.toString()]);
+  public getHasSubmittedProof(epochNumber: number, numberOfBlocksInEpoch: number, prover: Hex | EthAddress) {
+    if (prover instanceof EthAddress) {
+      prover = prover.toString();
+    }
+    return this.rollup.read.getHasSubmitted([BigInt(epochNumber), BigInt(numberOfBlocksInEpoch), prover]);
+  }
+
+  getManaBaseFeeAt(timestamp: bigint, inFeeAsset: boolean) {
+    return this.rollup.read.getManaBaseFeeAt([timestamp, inFeeAsset]);
+  }
+
+  getVersion() {
+    return this.rollup.read.getVersion();
+  }
+
+  getSlotAt(timestamp: bigint) {
+    return this.rollup.read.getSlotAt([timestamp]);
+  }
+
+  status(blockNumber: bigint, options?: { blockNumber?: bigint }) {
+    return this.rollup.read.status([blockNumber], options);
+  }
+
+  canPruneAtTime(timestamp: bigint, options?: { blockNumber?: bigint }) {
+    return this.rollup.read.canPruneAtTime([timestamp], options);
+  }
+
+  archive() {
+    return this.rollup.read.archive();
+  }
+
+  archiveAt(blockNumber: bigint) {
+    return this.rollup.read.archiveAt([blockNumber]);
+  }
+
+  getSequencerRewards(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getSequencerRewards([address]);
+  }
+
+  getSpecificProverRewardsForEpoch(epoch: bigint, prover: Hex | EthAddress) {
+    if (prover instanceof EthAddress) {
+      prover = prover.toString();
+    }
+    return this.rollup.read.getSpecificProverRewardsForEpoch([epoch, prover]);
+  }
+
+  getAttesters() {
+    return this.rollup.read.getAttesters();
+  }
+
+  getEpochCommittee(epoch: bigint) {
+    return this.rollup.read.getEpochCommittee([epoch]);
+  }
+
+  getInfo(address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    return this.rollup.read.getInfo([address]);
+  }
+
+  getBlobPublicInputsHash(blockNumber: bigint) {
+    return this.rollup.read.getBlobPublicInputsHash([blockNumber]);
+  }
+
+  getStakingAsset() {
+    return this.rollup.read.getStakingAsset();
+  }
+
+  getProposerForAttester(attester: Hex | EthAddress) {
+    if (attester instanceof EthAddress) {
+      attester = attester.toString();
+    }
+    return this.rollup.read.getProposerForAttester([attester]);
   }
 }

package/src/deploy_l1_contracts.ts

@@ -6,6 +6,8 @@ import {
   CoinIssuerBytecode,
   ExtRollupLibAbi,
   ExtRollupLibBytecode,
+  FeeAssetHandlerAbi,
+  FeeAssetHandlerBytecode,
   FeeJuicePortalAbi,
   FeeJuicePortalBytecode,
   ForwarderAbi,
@@ -188,6 +190,10 @@ export const l1Artifacts = {
     contractAbi: RegisterNewRollupVersionPayloadAbi,
     contractBytecode: RegisterNewRollupVersionPayloadBytecode as Hex,
   },
+  feeAssetHandler: {
+    contractAbi: FeeAssetHandlerAbi,
+    contractBytecode: FeeAssetHandlerBytecode as Hex,
+  },
 };
 
 export interface DeployL1ContractsArgs extends L1ContractsConfig {
@@ -328,6 +334,8 @@ export const deployRollup = async (
     minimumStake: args.minimumStake,
     slashingQuorum: args.slashingQuorum,
     slashingRoundSize: args.slashingRoundSize,
+    manaTarget: args.manaTarget,
+    provingCostPerMana: args.provingCostPerMana,
   };
   const genesisStateArgs = {
     vkTreeRoot: args.vkTreeRoot.toString(),
@@ -388,19 +396,15 @@ export const cheat_initializeValidatorSet = async (
   acceleratedTestDeployments: boolean | undefined,
   logger: Logger,
 ) => {
-  const rollup = getContract({
-    address: getAddress(rollupAddress.toString()),
-    abi: l1Artifacts.rollup.contractAbi,
-    client: clients.walletClient,
-  });
-  const minimumStake = await rollup.read.getMinimumStake();
+  const rollup = new RollupContract(clients.publicClient, rollupAddress);
+  const minimumStake = await rollup.getMinimumStake();
   if (validators && validators.length > 0) {
     // Check if some of the initial validators are already registered, so we support idempotent deployments
     if (!acceleratedTestDeployments) {
       const validatorsInfo = await Promise.all(
         validators.map(async address => ({
           address,
-          ...(await rollup.read.getInfo([address])),
+          ...(await rollup.getInfo(address)),
         })),
       );
       const existingValidators = validatorsInfo.filter(v => v.status !== 0);
@@ -460,6 +464,44 @@ export const cheat_initializeValidatorSet = async (
   }
 };
 
+/**
+ * Initialize the fee asset handler and make it a minter on the fee asset.
+ * @note This function will only be used for testing purposes.
+ *
+ * @param clients - The L1 clients.
+ * @param deployer - The L1 deployer.
+ * @param feeAssetAddress - The address of the fee asset.
+ * @param logger - The logger.
+ */
+// eslint-disable-next-line camelcase
+export const cheat_initializeFeeAssetHandler = async (
+  clients: L1Clients,
+  deployer: L1Deployer,
+  feeAssetAddress: EthAddress,
+  logger: Logger,
+): Promise<{
+  feeAssetHandlerAddress: EthAddress;
+  txHash: Hex;
+}> => {
+  const feeAssetHandlerAddress = await deployer.deploy(l1Artifacts.feeAssetHandler, [
+    clients.walletClient.account.address,
+    feeAssetAddress.toString(),
+    BigInt(1e18),
+  ]);
+  logger.verbose(`Deployed FeeAssetHandler at ${feeAssetHandlerAddress}`);
+
+  const { txHash } = await deployer.sendTransaction({
+    to: feeAssetAddress.toString(),
+    data: encodeFunctionData({
+      abi: l1Artifacts.feeAsset.contractAbi,
+      functionName: 'addMinter',
+      args: [feeAssetHandlerAddress.toString()],
+    }),
+  });
+  logger.verbose(`Added fee asset handler ${feeAssetHandlerAddress} as minter on fee asset in ${txHash}`);
+  return { feeAssetHandlerAddress, txHash };
+};
+
 /**
  * Deploys the aztec L1 contracts; Rollup & (optionally) Decoder Helper.
  * @param rpcUrls - List of URLs of the ETH RPC to use for deployment.
@@ -535,7 +577,7 @@ export const deployL1Contracts = async (
   // @note @LHerskind the assets are expected to be the same at some point, but for better
   // configurability they are different for now.
   const governanceAddress = await deployer.deploy(l1Artifacts.governance, [
-    feeAssetAddress.toString(),
+    stakingAssetAddress.toString(),
     governanceProposerAddress.toString(),
   ]);
   logger.verbose(`Deployed Governance at ${governanceAddress}`);
@@ -579,29 +621,24 @@ export const deployL1Contracts = async (
   // Transaction hashes to await
   const txHashes: Hex[] = [];
 
-  if (args.acceleratedTestDeployments || !(await feeAsset.read.freeForAll())) {
-    const { txHash } = await deployer.sendTransaction({
-      to: feeAssetAddress.toString(),
-      data: encodeFunctionData({
-        abi: l1Artifacts.feeAsset.contractAbi,
-        functionName: 'setFreeForAll',
-        args: [true],
-      }),
-    });
-    logger.verbose(`Fee asset set to free for all in ${txHash}`);
-    txHashes.push(txHash);
-  }
+  const { feeAssetHandlerAddress, txHash: feeAssetHandlerTxHash } = await cheat_initializeFeeAssetHandler(
+    clients,
+    deployer,
+    feeAssetAddress,
+    logger,
+  );
+  txHashes.push(feeAssetHandlerTxHash);
 
-  if (args.acceleratedTestDeployments || (await feeAsset.read.owner()) !== getAddress(coinIssuerAddress.toString())) {
+  if (args.acceleratedTestDeployments || !(await feeAsset.read.minters([coinIssuerAddress.toString()]))) {
     const { txHash } = await deployer.sendTransaction({
       to: feeAssetAddress.toString(),
       data: encodeFunctionData({
         abi: l1Artifacts.feeAsset.contractAbi,
-        functionName: 'transferOwnership',
+        functionName: 'addMinter',
         args: [coinIssuerAddress.toString()],
       }),
     });
-    logger.verbose(`Fee asset transferred ownership to coin issuer in ${txHash}`);
+    logger.verbose(`Added coin issuer ${coinIssuerAddress} as minter on fee asset in ${txHash}`);
     txHashes.push(txHash);
   }
 
@@ -754,6 +791,7 @@ export const deployL1Contracts = async (
     l1ContractAddresses: {
       ...l1Contracts,
       slashFactoryAddress,
+      feeAssetHandlerAddress,
     },
   };
 };

package/src/l1_contract_addresses.ts

@@ -26,7 +26,7 @@ export const L1ContractsNames = [
 /** Provides the directory of current L1 contract addresses */
 export type L1ContractAddresses = {
   [K in (typeof L1ContractsNames)[number]]: EthAddress;
-} & { slashFactoryAddress?: EthAddress | undefined };
+} & { slashFactoryAddress?: EthAddress | undefined; feeAssetHandlerAddress?: EthAddress | undefined };
 
 export const L1ContractAddressesSchema = z.object({
   rollupAddress: schemas.EthAddress,
@@ -41,6 +41,7 @@ export const L1ContractAddressesSchema = z.object({
   governanceProposerAddress: schemas.EthAddress,
   governanceAddress: schemas.EthAddress,
   slashFactoryAddress: schemas.EthAddress.optional(),
+  feeAssetHandlerAddress: schemas.EthAddress.optional(),
 }) satisfies ZodFor<L1ContractAddresses>;
 
 const parseEnv = (val: string) => EthAddress.fromString(val);
@@ -106,4 +107,9 @@ export const l1ContractAddressesMapping: ConfigMappingsType<L1ContractAddresses>
     description: 'The deployed L1 slashFactory contract address',
     parseEnv,
   },
+  feeAssetHandlerAddress: {
+    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
+    description: 'The deployed L1 feeAssetHandler contract address',
+    parseEnv,
+  },
 };

package/src/l1_tx_utils.ts

@@ -108,7 +108,7 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   maxGwei: {
     description: 'Maximum gas price in gwei',
     env: 'L1_GAS_PRICE_MAX',
-    ...bigintConfigHelper(100n),
+    ...bigintConfigHelper(500n),
   },
   maxBlobGwei: {
     description: 'Maximum blob fee per gas in gwei',
@@ -209,7 +209,6 @@ export class L1TxUtils {
       ...defaultL1TxUtilsConfig,
       ...(config || {}),
     };
-    this.logger?.debug('Initializing L1 TX utils with config', { config: this.config });
   }
 
   public interrupt() {

package/src/queries.ts

@@ -33,6 +33,8 @@ export async function getL1ContractsConfig(
     governanceProposerRoundSize,
     slashingQuorum,
     slashingRoundSize,
+    manaTarget,
+    provingCostPerMana,
   ] = await Promise.all([
     rollup.getL1StartBlock(),
     rollup.getL1GenesisTime(),
@@ -45,6 +47,8 @@ export async function getL1ContractsConfig(
     governanceProposer.getRoundSize(),
     slasherProposer.getQuorumSize(),
     slasherProposer.getRoundSize(),
+    rollup.getManaTarget(),
+    rollup.getProvingCostPerMana(),
   ] as const);
 
   return {
@@ -59,6 +63,8 @@ export async function getL1ContractsConfig(
     minimumStake,
     slashingQuorum: Number(slashingQuorum),
     slashingRoundSize: Number(slashingRoundSize),
+    manaTarget: manaTarget,
+    provingCostPerMana: provingCostPerMana,
   };
 }
 

package/src/test/upgrade_utils.ts

@@ -1,11 +1,12 @@
 import type { Logger } from '@aztec/foundation/log';
 import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
-import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts/TestERC20Abi';
+import { TestERC20Abi as StakingAssetAbi } from '@aztec/l1-artifacts/TestERC20Abi';
 
 import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
 
 import { EthCheatCodes } from '../eth_cheat_codes.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
+import { L1TxUtils } from '../l1_tx_utils.js';
 import type { L1Clients } from '../types.js';
 
 export async function executeGovernanceProposal(
@@ -20,13 +21,12 @@ export async function executeGovernanceProposal(
 ) {
   const proposal = await governance.read.getProposal([proposalId]);
 
+  const l1TxUtils = new L1TxUtils(publicClient, walletClient);
+
   const waitL1Block = async () => {
-    await publicClient.waitForTransactionReceipt({
-      hash: await walletClient.sendTransaction({
-        to: privateKey.address,
-        value: 1n,
-        account: privateKey,
-      }),
+    await l1TxUtils.sendAndMonitorTransaction({
+      to: walletClient.account.address,
+      value: 1n,
     });
   };
 
@@ -62,8 +62,8 @@ export async function createGovernanceProposal(
   logger: Logger,
 ): Promise<{ governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>; voteAmount: bigint }> {
   const token = getContract({
-    address: addresses.feeJuiceAddress.toString(),
-    abi: FeeJuiceAbi,
+    address: addresses.stakingAssetAddress.toString(),
+    abi: StakingAssetAbi,
     client: publicClient,
   });