@aztec/ethereum 0.0.0-test.0

package/src/contracts/forwarder.ts

@@ -0,0 +1,132 @@
+import { toHex } from '@aztec/foundation/bigint-buffer';
+import type { Logger } from '@aztec/foundation/log';
+import { ForwarderAbi, ForwarderBytecode } from '@aztec/l1-artifacts';
+
+import {
+  type EncodeFunctionDataParameters,
+  type GetContractReturnType,
+  type Hex,
+  encodeFunctionData,
+  getContract,
+} from 'viem';
+
+import { deployL1Contract } from '../deploy_l1_contracts.js';
+import type { L1BlobInputs, L1GasConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
+import type { L1Clients, ViemPublicClient, ViemWalletClient } from '../types.js';
+import { RollupContract } from './rollup.js';
+
+export class ForwarderContract {
+  private readonly forwarder: GetContractReturnType<typeof ForwarderAbi, ViemPublicClient>;
+
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex, public readonly rollupAddress: Hex) {
+    this.forwarder = getContract({ address, abi: ForwarderAbi, client });
+  }
+
+  static async create(
+    owner: Hex,
+    walletClient: ViemWalletClient,
+    publicClient: ViemPublicClient,
+    logger: Logger,
+    rollupAddress: Hex,
+  ) {
+    logger.info('Deploying forwarder contract');
+
+    const { address, txHash } = await deployL1Contract(
+      walletClient,
+      publicClient,
+      ForwarderAbi,
+      ForwarderBytecode,
+      [owner],
+      owner,
+      undefined,
+      logger,
+    );
+
+    if (txHash) {
+      await publicClient.waitForTransactionReceipt({ hash: txHash });
+    }
+
+    logger.info(`Forwarder contract deployed at ${address} with owner ${owner}`);
+
+    return new ForwarderContract(publicClient, address.toString(), rollupAddress);
+  }
+
+  public getAddress() {
+    return this.forwarder.address;
+  }
+
+  public async forward(
+    requests: L1TxRequest[],
+    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 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: encodedForwarderData,
+      },
+      gasConfig,
+      blobConfig,
+    );
+
+    if (receipt.status === 'success') {
+      const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
+      return { receipt, gasPrice, stats };
+    } else {
+      logger.error('Forwarder transaction failed', undefined, { receipt });
+
+      const args = {
+        ...forwarderFunctionData,
+        address: this.forwarder.address,
+      };
+
+      let errorMsg: string | undefined;
+
+      if (blobConfig) {
+        const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? gasPrice.maxFeePerBlobGas;
+        if (maxFeePerBlobGas === undefined) {
+          errorMsg = 'maxFeePerBlobGas is required to get the error message';
+        } else {
+          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 {
+        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.ts

@@ -0,0 +1,285 @@
+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 {
+  type EncodeFunctionDataParameters,
+  type GetContractReturnType,
+  type Hex,
+  encodeFunctionData,
+  getContract,
+} 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,
+  'governanceAddress' | 'rollupAddress' | 'registryAddress' | 'governanceProposerAddress'
+>;
+
+// NOTE: Must be kept in sync with DataStructures.ProposalState in l1-contracts
+export enum ProposalState {
+  Pending,
+  Active,
+  Queued,
+  Executable,
+  Rejected,
+  Executed,
+  Dropped,
+  Expired,
+}
+
+export class GovernanceContract {
+  private readonly publicGovernance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>;
+  private readonly walletGovernance: GetContractReturnType<typeof GovernanceAbi, ViemWalletClient> | undefined;
+
+  constructor(
+    address: Hex,
+    public readonly publicClient: ViemPublicClient,
+    public readonly walletClient: ViemWalletClient | undefined,
+  ) {
+    this.publicGovernance = getContract({ address, abi: GovernanceAbi, client: publicClient });
+    this.walletGovernance = walletClient
+      ? getContract({ address, abi: GovernanceAbi, client: walletClient })
+      : undefined;
+  }
+
+  public get address() {
+    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 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 getProposal(proposalId: bigint) {
+    return this.publicGovernance.read.getProposal([proposalId]);
+  }
+
+  public async getProposalState(proposalId: bigint): Promise<ProposalState> {
+    const state = await this.publicGovernance.read.getProposalState([proposalId]);
+    if (state < 0 || state > ProposalState.Expired) {
+      throw new Error(`Invalid proposal state: ${state}`);
+    }
+    return state as ProposalState;
+  }
+
+  private assertWalletGovernance(): NonNullable<typeof this.walletGovernance> {
+    if (!this.walletGovernance) {
+      throw new Error('Wallet client is required for this operation');
+    }
+    return this.walletGovernance;
+  }
+
+  public async deposit(onBehalfOf: Hex, amount: bigint) {
+    const walletGovernance = this.assertWalletGovernance();
+    const depositTx = await walletGovernance.write.deposit([onBehalfOf, amount]);
+    await this.publicClient.waitForTransactionReceipt({ hash: depositTx });
+  }
+
+  public async proposeWithLock({
+    payloadAddress,
+    withdrawAddress,
+  }: {
+    payloadAddress: Hex;
+    withdrawAddress: Hex;
+  }): Promise<number> {
+    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;
+  }
+
+  public async awaitProposalActive({ proposalId, logger }: { proposalId: bigint; logger: Logger }) {
+    const state = await this.getProposalState(proposalId);
+    if (state === ProposalState.Active) {
+      return;
+    } else if (state !== ProposalState.Pending) {
+      throw new Error(`Proposal ${proposalId} is in state [${state}]: it will never be active`);
+    } else {
+      const proposal = await this.getProposal(proposalId);
+      const startOfActive = proposal.creation + proposal.config.votingDelay;
+      const block = await this.publicClient.getBlock();
+      // Add 12 seconds to the time to make sure we don't vote too early
+      const secondsToActive = Number(startOfActive - block.timestamp) + 12;
+      const now = new Date();
+      logger.info(`
+        The time is ${now.toISOString()}.
+        The proposal will be active at ${new Date(Number(startOfActive) * 1000).toISOString()}.
+        Waiting ${secondsToActive} seconds for proposal to be active.
+        `);
+      await sleep(secondsToActive * 1000);
+    }
+  }
+
+  public async awaitProposalExecutable({ proposalId, logger }: { proposalId: bigint; logger: Logger }) {
+    const state = await this.getProposalState(proposalId);
+    if (state === ProposalState.Executable) {
+      return;
+    } else if (
+      ![ProposalState.Pending, ProposalState.Active, ProposalState.Queued, ProposalState.Executable].includes(state)
+    ) {
+      throw new Error(`Proposal ${proposalId} is in state [${state}]: it will never be executable`);
+    } else {
+      const proposal = await this.getProposal(proposalId);
+      const startOfExecutable =
+        proposal.creation +
+        proposal.config.votingDelay +
+        proposal.config.votingDuration +
+        proposal.config.executionDelay;
+      const block = await this.publicClient.getBlock();
+      const secondsToExecutable = Number(startOfExecutable - block.timestamp) + 12;
+      const now = new Date();
+      logger.info(`
+        The time is ${now.toISOString()}.
+        The proposal will be executable at ${new Date(Number(startOfExecutable) * 1000).toISOString()}.
+        Waiting ${secondsToExecutable} seconds for proposal to be executable.
+        `);
+      await sleep(secondsToExecutable * 1000);
+    }
+  }
+
+  public async getPower(): Promise<bigint> {
+    const walletGovernance = this.assertWalletGovernance();
+    const now = await this.publicClient.getBlock();
+    return walletGovernance.read.powerAt([this.walletClient!.account.address, now.timestamp]);
+  }
+
+  public async vote({
+    proposalId,
+    voteAmount,
+    inFavor,
+    retries = 10,
+    logger,
+  }: {
+    proposalId: bigint;
+    voteAmount: bigint | undefined;
+    inFavor: boolean;
+    retries: number;
+    logger: Logger;
+  }) {
+    const walletGovernance = this.assertWalletGovernance();
+    const l1TxUtils = new L1TxUtils(this.publicClient, this.walletClient!, logger);
+    const retryDelaySeconds = 12;
+
+    voteAmount = voteAmount ?? (await this.getPower());
+
+    let success = false;
+    for (let i = 0; i < retries; i++) {
+      try {
+        const voteFunctionData: EncodeFunctionDataParameters<typeof GovernanceAbi, 'vote'> = {
+          abi: GovernanceAbi,
+          functionName: 'vote',
+          args: [proposalId, voteAmount, inFavor],
+        };
+        const encodedVoteData = encodeFunctionData(voteFunctionData);
+
+        const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+          to: walletGovernance.address,
+          data: encodedVoteData,
+        });
+
+        if (receipt.status === 'success') {
+          success = true;
+          break;
+        } else {
+          const args = {
+            ...voteFunctionData,
+            address: walletGovernance.address,
+          };
+          const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedVoteData, args, undefined, []);
+          logger.error(`Error voting on proposal ${proposalId}: ${errorMsg}`);
+        }
+      } catch (error) {
+        logger.error(`Error voting on proposal ${proposalId}: ${error}`);
+      }
+
+      logger.info(`Retrying vote on proposal ${proposalId} in ${retryDelaySeconds} seconds`);
+      await sleep(retryDelaySeconds * 1000);
+    }
+    if (!success) {
+      throw new Error(`Failed to vote on proposal ${proposalId} after ${retries} retries`);
+    }
+    logger.info(`Voted [${inFavor ? 'yea' : 'nay'}] on proposal [${proposalId}]`);
+    const proposal = await this.getProposal(proposalId);
+    logger.info(`Proposal [${proposalId}] has state [${proposal.state}]`);
+    logger.info(`Proposal [${proposalId}] has summedBallot yea [${proposal.summedBallot.yea}]`);
+    logger.info(`Proposal [${proposalId}] has summedBallot nea [${proposal.summedBallot.nea}]`);
+  }
+
+  public async executeProposal({
+    proposalId,
+    retries = 10,
+    logger,
+  }: {
+    proposalId: bigint;
+    retries: number;
+    logger: Logger;
+  }) {
+    const walletGovernance = this.assertWalletGovernance();
+    const l1TxUtils = new L1TxUtils(this.publicClient, this.walletClient!, logger);
+    const retryDelaySeconds = 12;
+    let success = false;
+    for (let i = 0; i < retries; i++) {
+      try {
+        const executeFunctionData: EncodeFunctionDataParameters<typeof GovernanceAbi, 'execute'> = {
+          abi: GovernanceAbi,
+          functionName: 'execute',
+          args: [proposalId],
+        };
+        const encodedExecuteData = encodeFunctionData(executeFunctionData);
+
+        const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+          to: walletGovernance.address,
+          data: encodedExecuteData,
+        });
+
+        if (receipt.status === 'success') {
+          success = true;
+          break;
+        } else {
+          const args = {
+            ...executeFunctionData,
+            address: walletGovernance.address,
+          };
+          const errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedExecuteData, args, undefined, []);
+          logger.error(`Error executing proposal ${proposalId}: ${errorMsg}`);
+        }
+      } catch (error) {
+        logger.error(`Error executing proposal ${proposalId}: ${error}`);
+      }
+
+      logger.info(`Retrying execute proposal ${proposalId} in ${retryDelaySeconds} seconds`);
+      await sleep(retryDelaySeconds * 1000);
+    }
+    if (!success) {
+      throw new Error(`Failed to execute proposal ${proposalId} after ${retries} retries`);
+    } else {
+      logger.info(`Executed proposal ${proposalId}`);
+    }
+  }
+}

package/src/contracts/governance_proposer.ts

@@ -0,0 +1,82 @@
+import { memoize } from '@aztec/foundation/decorators';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { GovernanceProposerAbi } from '@aztec/l1-artifacts';
+
+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';
+
+export class GovernanceProposerContract implements IEmpireBase {
+  private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, ViemPublicClient>;
+
+  constructor(public readonly client: ViemPublicClient, address: Hex) {
+    this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
+  }
+
+  public get address() {
+    return EthAddress.fromString(this.proposer.address);
+  }
+
+  public async getRollupAddress() {
+    return EthAddress.fromString(await this.proposer.read.getInstance());
+  }
+
+  @memoize
+  public async getRegistryAddress() {
+    return EthAddress.fromString(await this.proposer.read.REGISTRY());
+  }
+
+  public getQuorumSize(): Promise<bigint> {
+    return this.proposer.read.N();
+  }
+
+  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

@@ -0,0 +1,8 @@
+export * from './empire_base.js';
+export * from './fee_juice.js';
+export * from './forwarder.js';
+export * from './governance.js';
+export * from './governance_proposer.js';
+export * from './registry.js';
+export * from './rollup.js';
+export * from './slashing_proposer.js';

package/src/contracts/registry.ts

@@ -0,0 +1,106 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { RegistryAbi } from '@aztec/l1-artifacts/RegistryAbi';
+import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
+
+import {
+  type Chain,
+  type GetContractReturnType,
+  type Hex,
+  type HttpTransport,
+  type PublicClient,
+  getContract,
+} from 'viem';
+
+import type { L1ContractAddresses } from '../l1_contract_addresses.js';
+import type { L1Clients, ViemPublicClient } from '../types.js';
+import { GovernanceContract } from './governance.js';
+import { RollupContract } from './rollup.js';
+
+export class RegistryContract {
+  public address: EthAddress;
+  private readonly registry: GetContractReturnType<typeof RegistryAbi, PublicClient<HttpTransport, Chain>>;
+
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex | EthAddress) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.address = EthAddress.fromString(address);
+    this.registry = getContract({ address, abi: RegistryAbi, client });
+  }
+
+  /**
+   * Returns the address of the rollup for a given version.
+   * @param version - The version of the rollup. 'canonical' can be used to get the canonical address (i.e. the latest version).
+   * @returns The address of the rollup. If the rollup is not set for this version, throws an error.
+   */
+  public async getRollupAddress(version: number | bigint | 'canonical'): Promise<EthAddress> {
+    if (version === 'canonical') {
+      return this.getCanonicalAddress();
+    }
+
+    if (typeof version === 'number') {
+      version = BigInt(version);
+    }
+
+    const snapshot = await this.registry.read.getSnapshot([version]);
+    const address = EthAddress.fromString(snapshot.rollup);
+    if (address.equals(EthAddress.ZERO)) {
+      throw new Error('Rollup address is undefined');
+    }
+    return address;
+  }
+
+  /**
+   * Returns the canonical address of the rollup.
+   * @returns The canonical address of the rollup. If the rollup is not set, throws an error.
+   */
+  public async getCanonicalAddress(): Promise<EthAddress> {
+    const snapshot = await this.registry.read.getCurrentSnapshot();
+    const address = EthAddress.fromString(snapshot.rollup);
+    if (address.equals(EthAddress.ZERO)) {
+      throw new Error('Rollup address is undefined');
+    }
+    return address;
+  }
+
+  public async getGovernanceAddresses(): Promise<
+    Pick<L1ContractAddresses, 'governanceProposerAddress' | 'governanceAddress'>
+  > {
+    const governanceAddress = await this.registry.read.getGovernance();
+    const governance = new GovernanceContract(governanceAddress, this.client, undefined);
+    const governanceProposer = await governance.getProposer();
+    return {
+      governanceAddress: governance.address,
+      governanceProposerAddress: governanceProposer.address,
+    };
+  }
+
+  public static async collectAddresses(
+    client: ViemPublicClient,
+    registryAddress: Hex | EthAddress,
+    rollupVersion: number | bigint | 'canonical',
+  ): Promise<L1ContractAddresses> {
+    const registry = new RegistryContract(client, registryAddress);
+    const governanceAddresses = await registry.getGovernanceAddresses();
+    const rollupAddress = await registry.getRollupAddress(rollupVersion);
+
+    if (rollupAddress === undefined) {
+      throw new Error('Rollup address is undefined');
+    }
+
+    const rollup = new RollupContract(client, rollupAddress);
+    const addresses = await rollup.getRollupAddresses();
+    const feeAsset = getContract({
+      address: addresses.feeJuiceAddress.toString(),
+      abi: TestERC20Abi,
+      client,
+    });
+    const coinIssuer = await feeAsset.read.owner();
+    return {
+      registryAddress: registry.address,
+      ...governanceAddresses,
+      ...addresses,
+      coinIssuerAddress: EthAddress.fromString(coinIssuer),
+    };
+  }
+}