@aztec/ethereum 0.78.1 → 0.80.0

package/src/contracts/governance.ts

@@ -1,20 +1,21 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { GovernanceAbi } from '@aztec/l1-artifacts';
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
 
 import {
   type EncodeFunctionDataParameters,
   type GetContractReturnType,
   type Hex,
+  type Log,
   encodeFunctionData,
   getContract,
+  parseEventLogs,
 } from 'viem';
 
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import { L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemPublicClient, ViemWalletClient } from '../types.js';
-import { GovernanceProposerContract } from './governance_proposer.js';
 
 export type L1GovernanceContractAddresses = Pick<
   L1ContractAddresses,
@@ -33,6 +34,19 @@ export enum ProposalState {
   Expired,
 }
 
+export function extractProposalIdFromLogs(logs: Log[]): bigint {
+  const parsedLogs = parseEventLogs({
+    abi: GovernanceAbi,
+    logs: logs,
+    eventName: 'Proposed',
+  });
+
+  if (parsedLogs.length === 0) {
+    throw new Error('Proposal log not found');
+  }
+  return parsedLogs[0].args.proposalId;
+}
+
 export class GovernanceContract {
   private readonly publicGovernance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>;
   private readonly walletGovernance: GetContractReturnType<typeof GovernanceAbi, ViemWalletClient> | undefined;
@@ -52,23 +66,12 @@ export class GovernanceContract {
     return EthAddress.fromString(this.publicGovernance.address);
   }
 
-  public async getProposer() {
-    const governanceProposerAddress = EthAddress.fromString(await this.publicGovernance.read.governanceProposer());
-    return new GovernanceProposerContract(this.publicClient, governanceProposerAddress.toString());
+  public async getGovernanceProposerAddress() {
+    return EthAddress.fromString(await this.publicGovernance.read.governanceProposer());
   }
 
-  public async getGovernanceAddresses(): Promise<L1GovernanceContractAddresses> {
-    const governanceProposer = await this.getProposer();
-    const [rollupAddress, registryAddress] = await Promise.all([
-      governanceProposer.getRollupAddress(),
-      governanceProposer.getRegistryAddress(),
-    ]);
-    return {
-      governanceAddress: this.address,
-      rollupAddress,
-      registryAddress,
-      governanceProposerAddress: governanceProposer.address,
-    };
+  public getConfiguration() {
+    return this.publicGovernance.read.getConfiguration();
   }
 
   public getProposal(proposalId: bigint) {
@@ -102,16 +105,14 @@ export class GovernanceContract {
   }: {
     payloadAddress: Hex;
     withdrawAddress: Hex;
-  }): Promise<number> {
+  }): Promise<bigint> {
     const walletGovernance = this.assertWalletGovernance();
     const proposeTx = await walletGovernance.write.proposeWithLock([payloadAddress, withdrawAddress]);
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash: proposeTx });
     if (receipt.status !== 'success') {
       throw new Error(`Proposal failed: ${receipt.status}`);
     }
-
-    const proposalId = Number(receipt.logs[1].topics[1]);
-    return proposalId;
+    return extractProposalIdFromLogs(receipt.logs);
   }
 
   public async awaitProposalActive({ proposalId, logger }: { proposalId: bigint; logger: Logger }) {

package/src/contracts/governance_proposer.ts

@@ -1,12 +1,13 @@
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { GovernanceProposerAbi } from '@aztec/l1-artifacts';
+import { GovernanceProposerAbi } from '@aztec/l1-artifacts/GovernanceProposerAbi';
 
 import { type GetContractReturnType, type Hex, type TransactionReceipt, encodeFunctionData, getContract } from 'viem';
 
 import type { GasPrice, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
 import type { ViemPublicClient } from '../types.js';
 import { type IEmpireBase, encodeVote } from './empire_base.js';
+import { extractProposalIdFromLogs } from './governance.js';
 
 export class GovernanceProposerContract implements IEmpireBase {
   private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, ViemPublicClient>;
@@ -63,14 +64,15 @@ export class GovernanceProposerContract implements IEmpireBase {
     };
   }
 
-  public executeProposal(
+  public async executeProposal(
     round: bigint,
     l1TxUtils: L1TxUtils,
   ): Promise<{
     receipt: TransactionReceipt;
     gasPrice: GasPrice;
+    proposalId: bigint;
   }> {
-    return l1TxUtils.sendAndMonitorTransaction({
+    const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
       data: encodeFunctionData({
         abi: this.proposer.abi,
@@ -78,5 +80,7 @@ export class GovernanceProposerContract implements IEmpireBase {
         args: [round],
       }),
     });
+    const proposalId = extractProposalIdFromLogs(receipt.logs);
+    return { receipt, gasPrice, proposalId };
   }
 }

package/src/contracts/registry.ts

@@ -68,10 +68,10 @@ export class RegistryContract {
   > {
     const governanceAddress = await this.registry.read.getGovernance();
     const governance = new GovernanceContract(governanceAddress, this.client, undefined);
-    const governanceProposer = await governance.getProposer();
+    const governanceProposerAddress = await governance.getGovernanceProposerAddress();
     return {
       governanceAddress: governance.address,
-      governanceProposerAddress: governanceProposer.address,
+      governanceProposerAddress: governanceProposerAddress,
     };
   }
 
@@ -103,4 +103,9 @@ export class RegistryContract {
       coinIssuerAddress: EthAddress.fromString(coinIssuer),
     };
   }
+
+  public async getNumberOfVersions(): Promise<number> {
+    const version = await this.registry.read.numberOfVersions();
+    return Number(version);
+  }
 }

package/src/contracts/rollup.ts

@@ -1,7 +1,9 @@
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
-import { RollupAbi, RollupStorage, SlasherAbi } from '@aztec/l1-artifacts';
+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, getAddress, getContract } from 'viem';
 

package/src/contracts/slashing_proposer.ts

@@ -1,5 +1,5 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlashingProposerAbi } from '@aztec/l1-artifacts';
+import { SlashingProposerAbi } from '@aztec/l1-artifacts/SlashingProposerAbi';
 
 import { type GetContractReturnType, type Hex, getContract } from 'viem';
 

package/src/deploy_l1_contracts.ts

@@ -66,7 +66,7 @@ import {
   type L1TxRequest,
   L1TxUtils,
   type L1TxUtilsConfig,
-  defaultL1TxUtilsConfig,
+  getL1TxUtilsConfigEnvVars,
 } from './l1_tx_utils.js';
 import type { L1Clients, ViemPublicClient, ViemWalletClient } from './types.js';
 
@@ -257,7 +257,15 @@ export function createL1Clients(
   return { walletClient, publicClient } as L1Clients;
 }
 
-export const deployRollupAndPeriphery = async (
+/**
+ * Deploys the rollup, slash factory, and the payload which can be used to make the rollup the canonical version.
+ * @param clients - The L1 clients.
+ * @param args - The deployment arguments.
+ * @param registryAddress - The address of the registry.
+ * @param logger - The logger.
+ * @param txUtilsConfig - The L1 tx utils config.
+ */
+export const deployRollupForUpgrade = async (
   clients: L1Clients,
   args: DeployL1ContractsArgs,
   registryAddress: EthAddress,
@@ -343,22 +351,56 @@ export const deployRollup = async (
   await deployer.waitForDeployments();
   logger.verbose(`All core contracts have been deployed`);
 
+  if (args.initialValidators) {
+    await cheat_initializeValidatorSet(
+      clients,
+      deployer,
+      rollupAddress.toString(),
+      addresses.stakingAssetAddress.toString(),
+      args.initialValidators.map(v => v.toString()),
+      args.acceleratedTestDeployments,
+      logger,
+    );
+  }
+
+  return new RollupContract(clients.publicClient, rollupAddress);
+};
+
+/**
+ * Initialize the validator set for the rollup using a cheat function.
+ * @note This function will only be used when the chain is local anvil node soon (#12050)
+ *
+ * @param clients - The L1 clients.
+ * @param deployer - The L1 deployer.
+ * @param rollupAddress - The address of the rollup.
+ * @param stakingAssetAddress - The address of the staking asset.
+ * @param validators - The validators to initialize.
+ * @param acceleratedTestDeployments - Whether to use accelerated test deployments.
+ * @param logger - The logger.
+ */
+// eslint-disable-next-line camelcase
+export const cheat_initializeValidatorSet = async (
+  clients: L1Clients,
+  deployer: L1Deployer,
+  rollupAddress: Hex,
+  stakingAssetAddress: Hex,
+  validators: Hex[],
+  acceleratedTestDeployments: boolean | undefined,
+  logger: Logger,
+) => {
   const rollup = getContract({
     address: getAddress(rollupAddress.toString()),
     abi: l1Artifacts.rollup.contractAbi,
     client: clients.walletClient,
   });
-
-  const txHashes: Hex[] = [];
-
-  if (args.initialValidators && args.initialValidators.length > 0) {
+  const minimumStake = await rollup.read.getMinimumStake();
+  if (validators && validators.length > 0) {
     // Check if some of the initial validators are already registered, so we support idempotent deployments
-    let newValidatorsAddresses = args.initialValidators.map(v => v.toString());
-    if (!args.acceleratedTestDeployments) {
+    if (!acceleratedTestDeployments) {
       const validatorsInfo = await Promise.all(
-        args.initialValidators.map(async address => ({
+        validators.map(async address => ({
           address,
-          ...(await rollup.read.getInfo([address.toString()])),
+          ...(await rollup.read.getInfo([address])),
         })),
       );
       const existingValidators = validatorsInfo.filter(v => v.status !== 0);
@@ -370,16 +412,16 @@ export const deployRollup = async (
         );
       }
 
-      newValidatorsAddresses = validatorsInfo.filter(v => v.status === 0).map(v => v.address.toString());
+      validators = validatorsInfo.filter(v => v.status === 0).map(v => v.address);
     }
 
-    if (newValidatorsAddresses.length > 0) {
+    if (validators.length > 0) {
       // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
-      const stakeNeeded = args.minimumStake * BigInt(newValidatorsAddresses.length);
+      const stakeNeeded = minimumStake * BigInt(validators.length);
       await Promise.all(
         [
           await deployer.sendTransaction({
-            to: addresses.stakingAssetAddress.toString(),
+            to: stakingAssetAddress,
             data: encodeFunctionData({
               abi: l1Artifacts.stakingAsset.contractAbi,
               functionName: 'mint',
@@ -387,40 +429,35 @@ export const deployRollup = async (
             }),
           }),
           await deployer.sendTransaction({
-            to: addresses.stakingAssetAddress.toString(),
+            to: stakingAssetAddress,
             data: encodeFunctionData({
               abi: l1Artifacts.stakingAsset.contractAbi,
               functionName: 'approve',
-              args: [rollupAddress.toString(), stakeNeeded],
+              args: [rollupAddress, stakeNeeded],
             }),
           }),
         ].map(tx => clients.publicClient.waitForTransactionReceipt({ hash: tx.txHash })),
       );
 
-      const validators = newValidatorsAddresses.map(v => ({
+      const validatorsTuples = validators.map(v => ({
         attester: v,
         proposer: getExpectedAddress(ForwarderAbi, ForwarderBytecode, [v], v).address,
         withdrawer: v,
-        amount: args.minimumStake,
+        amount: minimumStake,
       }));
-      // const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([validators]);
       const initiateValidatorSetTxHash = await deployer.walletClient.writeContract({
-        address: rollupAddress.toString(),
+        address: rollupAddress,
         abi: l1Artifacts.rollup.contractAbi,
         functionName: 'cheat__InitialiseValidatorSet',
-        args: [validators],
+        args: [validatorsTuples],
       });
-      txHashes.push(initiateValidatorSetTxHash);
+      await clients.publicClient.waitForTransactionReceipt({ hash: initiateValidatorSetTxHash });
       logger.info(`Initialized validator set`, {
         validators,
         txHash: initiateValidatorSetTxHash,
       });
     }
   }
-
-  await Promise.all(txHashes.map(txHash => clients.publicClient.waitForTransactionReceipt({ hash: txHash })));
-
-  return new RollupContract(clients.publicClient, rollupAddress);
 };
 
 /**
@@ -438,7 +475,7 @@ export const deployL1Contracts = async (
   chain: Chain,
   logger: Logger,
   args: DeployL1ContractsArgs,
-  txUtilsConfig: L1TxUtilsConfig = defaultL1TxUtilsConfig,
+  txUtilsConfig: L1TxUtilsConfig = getL1TxUtilsConfigEnvVars(),
 ): Promise<DeployL1ContractsReturnType> => {
   const clients = createL1Clients(rpcUrls, account, chain);
   const { walletClient, publicClient } = clients;
@@ -809,7 +846,8 @@ export async function deployL1Contract(
   let resultingAddress: Hex | null | undefined = undefined;
 
   if (!l1TxUtils) {
-    l1TxUtils = new L1TxUtils(publicClient, walletClient, logger, undefined, acceleratedTestDeployments);
+    const config = getL1TxUtilsConfigEnvVars();
+    l1TxUtils = new L1TxUtils(publicClient, walletClient, logger, config, acceleratedTestDeployments);
   }
 
   if (libraries) {

package/src/l1_tx_utils.ts

@@ -2,6 +2,7 @@ import { compactArray, times } from '@aztec/foundation/collection';
 import {
   type ConfigMappingsType,
   bigintConfigHelper,
+  getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
 } from '@aztec/foundation/config';
@@ -158,6 +159,10 @@ export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
 
 export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(l1TxUtilsConfigMappings);
 
+export function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig {
+  return getConfigFromMappings(l1TxUtilsConfigMappings);
+}
+
 export interface L1TxRequest {
   to: Address | null;
   data?: Hex;

package/src/queries.ts

@@ -1,7 +1,11 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import type { Hex } from 'viem';
 
 import type { L1ContractsConfig } from './config.js';
 import { GovernanceContract } from './contracts/governance.js';
+import { GovernanceProposerContract } from './contracts/governance_proposer.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { ViemPublicClient } from './types.js';
 
@@ -11,8 +15,9 @@ export async function getL1ContractsConfig(
   addresses: { governanceAddress: EthAddress; rollupAddress?: EthAddress },
 ): Promise<Omit<L1ContractsConfig, 'ethereumSlotDuration'> & { l1StartBlock: bigint; l1GenesisTime: bigint }> {
   const governance = new GovernanceContract(addresses.governanceAddress.toString(), publicClient, undefined);
-  const governanceProposer = await governance.getProposer();
-  const rollupAddress = addresses.rollupAddress ?? (await governance.getGovernanceAddresses()).rollupAddress;
+  const governanceProposerAddress = await governance.getGovernanceProposerAddress();
+  const governanceProposer = new GovernanceProposerContract(publicClient, governanceProposerAddress.toString());
+  const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
 
@@ -56,3 +61,25 @@ export async function getL1ContractsConfig(
     slashingRoundSize: Number(slashingRoundSize),
   };
 }
+
+export type L2BlockProposedEvent = {
+  versionedBlobHashes: readonly Hex[];
+  archive: Hex;
+  blockNumber: bigint;
+};
+
+export async function getL2BlockProposalEvents(
+  client: ViemPublicClient,
+  blockId: Hex,
+  rollupAddress?: EthAddress,
+): Promise<L2BlockProposedEvent[]> {
+  return (
+    await client.getContractEvents({
+      abi: RollupAbi,
+      address: rollupAddress?.toString(),
+      blockHash: blockId,
+      eventName: 'L2BlockProposed',
+      strict: true,
+    })
+  ).map(log => log.args);
+}

package/src/test/chain_monitor.ts

@@ -0,0 +1,88 @@
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { createLogger } from '@aztec/foundation/log';
+
+import type { PublicClient } from 'viem';
+
+/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
+export class ChainMonitor {
+  private readonly l1Client: PublicClient;
+  private handle: NodeJS.Timeout | undefined;
+
+  /** Current L1 block number */
+  public l1BlockNumber!: number;
+  /** Current L2 block number */
+  public l2BlockNumber!: number;
+  /** Current L2 proven block number */
+  public l2ProvenBlockNumber!: number;
+  /** L1 timestamp for the current L2 block */
+  public l2BlockTimestamp!: bigint;
+  /** L1 timestamp for the proven L2 block */
+  public l2ProvenBlockTimestamp!: bigint;
+
+  constructor(
+    private readonly rollup: RollupContract,
+    private logger = createLogger('aztecjs:utils:chain_monitor'),
+    private readonly intervalMs = 200,
+  ) {
+    this.l1Client = rollup.client;
+  }
+
+  start() {
+    if (this.handle) {
+      throw new Error('Chain monitor already started');
+    }
+    this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
+    return this;
+  }
+
+  stop() {
+    if (this.handle) {
+      clearInterval(this.handle!);
+      this.handle = undefined;
+    }
+  }
+
+  private safeRun() {
+    void this.run().catch(error => {
+      this.logger.error('Error in chain monitor loop', error);
+    });
+  }
+
+  async run() {
+    const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({ cacheTime: 0 }));
+    if (this.l1BlockNumber === newL1BlockNumber) {
+      return;
+    }
+    this.l1BlockNumber = newL1BlockNumber;
+
+    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
+    const timestamp = block.timestamp;
+    const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
+
+    let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
+
+    const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
+    if (this.l2BlockNumber !== newL2BlockNumber) {
+      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
+      msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
+      this.l2BlockNumber = newL2BlockNumber;
+      this.l2BlockTimestamp = timestamp;
+    }
+
+    const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
+    if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
+      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
+      msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
+      this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
+      this.l2ProvenBlockTimestamp = timestamp;
+    }
+
+    this.logger.info(msg, {
+      l1Timestamp: timestamp,
+      l1BlockNumber: this.l1BlockNumber,
+      l2SlotNumber: await this.rollup.getSlotNumber(),
+      l2BlockNumber: this.l2BlockNumber,
+      l2ProvenBlockNumber: this.l2ProvenBlockNumber,
+    });
+  }
+}

package/src/test/index.ts

@@ -3,3 +3,4 @@ export * from './eth_cheat_codes_with_state.js';
 export * from './start_anvil.js';
 export * from './tx_delayer.js';
 export * from './upgrade_utils.js';
+export * from './chain_monitor.js';

package/src/test/upgrade_utils.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@aztec/foundation/log';
-import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
 import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts/TestERC20Abi';
 
 import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
 

package/src/utils.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
-import { ErrorsAbi } from '@aztec/l1-artifacts';
+import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,