@aztec/ethereum 0.0.0-test.0

package/src/l1_tx_utils_with_blobs.ts

@@ -0,0 +1,86 @@
+import { Blob } from '@aztec/blob-lib';
+
+import { formatGwei } from 'viem';
+
+import { type GasPrice, L1TxUtils } from './l1_tx_utils.js';
+
+export class L1TxUtilsWithBlobs extends L1TxUtils {
+  /**
+   * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
+   * @param nonce - The nonce of the transaction to cancel
+   * @param previousGasPrice - The gas price of the previous transaction
+   * @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) {
+    const account = this.walletClient.account;
+
+    // Get gas price with higher priority fee for cancellation
+    const cancelGasPrice = await this.getGasPrice(
+      {
+        ...this.config,
+        // Use high bump for cancellation to ensure it replaces the original tx
+        priorityFeeRetryBumpPercentage: 150, // 150% bump should be enough to replace any tx
+      },
+      isBlobTx,
+      attempts + 1,
+      previousGasPrice,
+    );
+
+    this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
+      maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
+      maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas),
+    });
+    const request = {
+      to: account.address,
+      value: 0n,
+    };
+
+    // Send 0-value tx to self with higher gas price
+    if (!isBlobTx) {
+      const cancelTxHash = await this.walletClient.sendTransaction({
+        ...request,
+        nonce,
+        gas: 21_000n, // Standard ETH transfer gas
+        maxFeePerGas: cancelGasPrice.maxFeePerGas,
+        maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
+      });
+      const receipt = await this.monitorTransaction(
+        request,
+        cancelTxHash,
+        { gasLimit: 21_000n },
+        undefined,
+        undefined,
+        true,
+      );
+
+      return receipt.transactionHash;
+    } else {
+      const blobData = new Uint8Array(131072).fill(0);
+      const kzg = Blob.getViemKzgInstance();
+      const blobInputs = {
+        blobs: [blobData],
+        kzg,
+        maxFeePerBlobGas: cancelGasPrice.maxFeePerBlobGas!,
+      };
+      const cancelTxHash = await this.walletClient.sendTransaction({
+        ...request,
+        ...blobInputs,
+        nonce,
+        gas: 21_000n,
+        maxFeePerGas: cancelGasPrice.maxFeePerGas,
+        maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas,
+      });
+      const receipt = await this.monitorTransaction(
+        request,
+        cancelTxHash,
+        { gasLimit: 21_000n },
+        undefined,
+        blobInputs,
+        true,
+      );
+
+      return receipt.transactionHash;
+    }
+  }
+}

package/src/queries.ts

@@ -0,0 +1,58 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import type { L1ContractsConfig } from './config.js';
+import { GovernanceContract } from './contracts/governance.js';
+import { RollupContract } from './contracts/rollup.js';
+import type { ViemPublicClient } from './types.js';
+
+/** Reads the L1ContractsConfig from L1 contracts. */
+export async function getL1ContractsConfig(
+  publicClient: ViemPublicClient,
+  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 rollup = new RollupContract(publicClient, rollupAddress.toString());
+  const slasherProposer = await rollup.getSlashingProposer();
+
+  const [
+    l1StartBlock,
+    l1GenesisTime,
+    aztecEpochDuration,
+    aztecProofSubmissionWindow,
+    aztecSlotDuration,
+    aztecTargetCommitteeSize,
+    minimumStake,
+    governanceProposerQuorum,
+    governanceProposerRoundSize,
+    slashingQuorum,
+    slashingRoundSize,
+  ] = await Promise.all([
+    rollup.getL1StartBlock(),
+    rollup.getL1GenesisTime(),
+    rollup.getEpochDuration(),
+    rollup.getProofSubmissionWindow(),
+    rollup.getSlotDuration(),
+    rollup.getTargetCommitteeSize(),
+    rollup.getMinimumStake(),
+    governanceProposer.getQuorumSize(),
+    governanceProposer.getRoundSize(),
+    slasherProposer.getQuorumSize(),
+    slasherProposer.getRoundSize(),
+  ] as const);
+
+  return {
+    l1StartBlock,
+    l1GenesisTime,
+    aztecEpochDuration: Number(aztecEpochDuration),
+    aztecProofSubmissionWindow: Number(aztecProofSubmissionWindow),
+    aztecSlotDuration: Number(aztecSlotDuration),
+    aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    governanceProposerQuorum: Number(governanceProposerQuorum),
+    governanceProposerRoundSize: Number(governanceProposerRoundSize),
+    minimumStake,
+    slashingQuorum: Number(slashingQuorum),
+    slashingRoundSize: Number(slashingRoundSize),
+  };
+}

package/src/test/delayed_tx_utils.ts

@@ -0,0 +1,24 @@
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { type Delayer, withDelayer } from './tx_delayer.js';
+
+export class DelayedTxUtils extends L1TxUtilsWithBlobs {
+  public delayer: Delayer | undefined;
+
+  public static fromL1TxUtils(l1TxUtils: L1TxUtilsWithBlobs, ethereumSlotDuration: number) {
+    const { client, delayer } = withDelayer(l1TxUtils.walletClient, {
+      ethereumSlotDuration,
+    });
+    const casted = l1TxUtils as unknown as DelayedTxUtils;
+    casted.delayer = delayer;
+    casted.walletClient = client;
+    return casted;
+  }
+
+  public enableDelayer(ethereumSlotDuration: number) {
+    const { client, delayer } = withDelayer(this.walletClient, {
+      ethereumSlotDuration,
+    });
+    this.delayer = delayer;
+    this.walletClient = client;
+  }
+}

package/src/test/eth_cheat_codes_with_state.ts

@@ -0,0 +1,38 @@
+import fs from 'fs';
+
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+
+/**
+ * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
+ * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.
+ */
+export class EthCheatCodesWithState extends EthCheatCodes {
+  /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */
+  public async dumpChainState(fileName: string): Promise<void> {
+    let res: any;
+    try {
+      res = await this.rpcCall('hardhat_dumpState', []);
+    } catch (e) {
+      throw new Error(`Error dumping state: ${e}`);
+    }
+    fs.writeFileSync(`${fileName}.json`, res, 'utf8');
+    this.logger.verbose(`Dumped state to ${fileName}`);
+  }
+
+  /**
+   * Loads the chain state from a file.
+   * @param fileName - The file name to load state from
+   */
+  public async loadChainState(fileName: string): Promise<void> {
+    const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
+    try {
+      await this.rpcCall('hardhat_loadState', [data]);
+    } catch (e) {
+      throw new Error(`Error loading state: ${e}`);
+    }
+    this.logger.verbose(`Loaded state from ${fileName}`);
+  }
+}

package/src/test/index.ts

@@ -0,0 +1,5 @@
+export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes_with_state.js';
+export * from './start_anvil.js';
+export * from './tx_delayer.js';
+export * from './upgrade_utils.js';

package/src/test/start_anvil.ts

@@ -0,0 +1,52 @@
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { type Anvil, createAnvil } from '@viem/anvil';
+import { dirname, resolve } from 'path';
+
+/**
+ * Ensures there's a running Anvil instance and returns the RPC URL.
+ */
+export async function startAnvil(
+  opts: {
+    l1BlockTime?: number;
+  } = {},
+): Promise<{ anvil: Anvil; rpcUrl: string; stop: () => Promise<void> }> {
+  const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+
+  let port: number | undefined;
+
+  // Start anvil.
+  // We go via a wrapper script to ensure if the parent dies, anvil dies.
+  const anvil = await retry(
+    async () => {
+      const anvil = createAnvil({
+        anvilBinary,
+        port: 0,
+        blockTime: opts.l1BlockTime,
+        stopTimeout: 1000,
+      });
+
+      // Listen to the anvil output to get the port.
+      const removeHandler = anvil.on('message', (message: string) => {
+        if (port === undefined && message.includes('Listening on')) {
+          port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)![2]);
+        }
+      });
+      await anvil.start();
+      removeHandler();
+
+      return anvil;
+    },
+    'Start anvil',
+    makeBackoff([5, 5, 5]),
+  );
+
+  if (!port) {
+    throw new Error('Failed to start anvil');
+  }
+
+  // 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}` };
+}

package/src/test/tx_delayer.ts

@@ -0,0 +1,163 @@
+import { omit } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { inspect } from 'util';
+import {
+  type Client,
+  type Hex,
+  type PublicClient,
+  keccak256,
+  parseTransaction,
+  publicActions,
+  walletActions,
+} from 'viem';
+
+import type { ViemWalletClient } from '../types.js';
+
+export function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger) {
+  const publicClient =
+    'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
+      ? (client as unknown as PublicClient)
+      : client.extend(publicActions);
+
+  return retryUntil(
+    async () => {
+      const currentBlockNumber = await publicClient.getBlockNumber({ cacheTime: 0 });
+      logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
+      return currentBlockNumber >= BigInt(blockNumber);
+    },
+    `Wait until L1 block ${blockNumber}`,
+    120,
+    0.1,
+  );
+}
+
+export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger) {
+  const publicClient =
+    'getBlockNumber' in client && typeof client.getBlockNumber === 'function'
+      ? (client as unknown as PublicClient)
+      : client.extend(publicActions);
+
+  let lastBlock: bigint | undefined = undefined;
+  return retryUntil(
+    async () => {
+      const currentBlockNumber = await publicClient.getBlockNumber({ cacheTime: 0 });
+      if (currentBlockNumber === lastBlock) {
+        return false;
+      }
+      lastBlock = currentBlockNumber;
+      const currentBlock = await publicClient.getBlock({ includeTransactions: false, blockNumber: currentBlockNumber });
+      const currentTs = currentBlock.timestamp;
+      logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
+      return currentTs >= BigInt(timestamp);
+    },
+    `Wait until L1 timestamp ${timestamp}`,
+    120,
+    0.1,
+  );
+}
+
+export interface Delayer {
+  /** Returns the list of all txs (not just the delayed ones) sent through the attached client. */
+  getTxs(): Hex[];
+  /** Delays the next tx to be sent so it lands on the given L1 block number. */
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint | undefined): void;
+  /** Delays the next tx to be sent so it lands on the given timestamp. */
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
+}
+
+class DelayerImpl implements Delayer {
+  constructor(opts: { ethereumSlotDuration: bigint | number }) {
+    this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+  }
+
+  public ethereumSlotDuration: bigint;
+  public nextWait: { l1Timestamp: bigint } | { l1BlockNumber: bigint } | undefined = undefined;
+  public txs: Hex[] = [];
+
+  getTxs() {
+    return this.txs;
+  }
+
+  pauseNextTxUntilBlock(l1BlockNumber: number | bigint) {
+    this.nextWait = { l1BlockNumber: BigInt(l1BlockNumber) };
+  }
+
+  pauseNextTxUntilTimestamp(l1Timestamp: number | bigint) {
+    this.nextWait = { l1Timestamp: BigInt(l1Timestamp) };
+  }
+}
+
+/**
+ * Returns a new client (without modifying the one passed in) with an injected tx delayer.
+ * The delayer can be used to hold off the next tx to be sent until a given block number.
+ * TODO(#10824): This doesn't play along well with blob txs for some reason.
+ */
+export function withDelayer<T extends ViemWalletClient>(
+  client: T,
+  opts: { ethereumSlotDuration: bigint | number },
+): { client: T; delayer: Delayer } {
+  const logger = createLogger('ethereum:tx_delayer');
+  const delayer = new DelayerImpl(opts);
+  const extended = client
+    // Tweak sendRawTransaction so it uses the delay defined in the delayer.
+    // Note that this will only work with local accounts (ie accounts for which we have the private key).
+    // Transactions signed by the node will not be delayed since they use sendTransaction directly,
+    // but we do not use them in our codebase at all.
+    .extend(client => ({
+      async sendRawTransaction(...args) {
+        if (delayer.nextWait !== undefined) {
+          const waitUntil = delayer.nextWait;
+          delayer.nextWait = undefined;
+
+          const publicClient = client as unknown as PublicClient;
+          const wait =
+            'l1BlockNumber' in waitUntil
+              ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger)
+              : waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger);
+
+          // Compute the tx hash manually so we emulate sendRawTransaction response
+          const { serializedTransaction } = args[0];
+          const txHash = keccak256(serializedTransaction);
+          logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+            argsLen: args.length,
+            ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+          });
+
+          // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
+          // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
+          // mine it immediately.
+          void wait
+            .then(async () => {
+              const clientTxHash = await client.sendRawTransaction(...args);
+              if (clientTxHash !== txHash) {
+                logger.error(`Tx hash returned by the client does not match computed one`, {
+                  clientTxHash,
+                  computedTxHash: txHash,
+                });
+              }
+              logger.info(`Sent previously delayed tx ${clientTxHash} to land on ${inspect(waitUntil)}`);
+              delayer.txs.push(clientTxHash);
+            })
+            .catch(err => logger.error(`Error sending tx after delay`, err));
+
+          return Promise.resolve(txHash);
+        } else {
+          const txHash = await client.sendRawTransaction(...args);
+          logger.verbose(`Sent tx immediately ${txHash}`);
+          delayer.txs.push(txHash);
+          return txHash;
+        }
+      },
+    }))
+    // Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+    .extend(client => ({ sendTransaction: walletActions(client).sendTransaction }))
+    // And with the actions that depend on the modified sendTransaction
+    .extend(client => ({
+      writeContract: walletActions(client).writeContract,
+      deployContract: walletActions(client).deployContract,
+    })) as T;
+
+  return { client: extended, delayer };
+}

package/src/test/upgrade_utils.ts

@@ -0,0 +1,100 @@
+import type { Logger } from '@aztec/foundation/log';
+import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+
+import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
+
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+import type { L1ContractAddresses } from '../l1_contract_addresses.js';
+import type { L1Clients } from '../types.js';
+
+export async function executeGovernanceProposal(
+  proposalId: bigint,
+  governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>,
+  voteAmount: bigint,
+  privateKey: PrivateKeyAccount,
+  publicClient: L1Clients['publicClient'],
+  walletClient: L1Clients['walletClient'],
+  rpcUrls: string[],
+  logger: Logger,
+) {
+  const proposal = await governance.read.getProposal([proposalId]);
+
+  const waitL1Block = async () => {
+    await publicClient.waitForTransactionReceipt({
+      hash: await walletClient.sendTransaction({
+        to: privateKey.address,
+        value: 1n,
+        account: privateKey,
+      }),
+    });
+  };
+
+  const cheatCodes = new EthCheatCodes(rpcUrls, logger);
+
+  const timeToActive = proposal.creation + proposal.config.votingDelay;
+  logger.info(`Warping to ${timeToActive + 1n}`);
+  await cheatCodes.warp(Number(timeToActive + 1n));
+  logger.info(`Warped to ${timeToActive + 1n}`);
+  await waitL1Block();
+
+  logger.info(`Voting`);
+  const voteTx = await governance.write.vote([proposalId, voteAmount, true], { account: privateKey });
+  await publicClient.waitForTransactionReceipt({ hash: voteTx });
+  logger.info(`Voted`);
+
+  const timeToExecutable = timeToActive + proposal.config.votingDuration + proposal.config.executionDelay + 1n;
+  logger.info(`Warping to ${timeToExecutable}`);
+  await cheatCodes.warp(Number(timeToExecutable));
+  logger.info(`Warped to ${timeToExecutable}`);
+  await waitL1Block();
+
+  const executeTx = await governance.write.execute([proposalId], { account: privateKey });
+  await publicClient.waitForTransactionReceipt({ hash: executeTx });
+  logger.info(`Executed proposal`);
+}
+
+export async function createGovernanceProposal(
+  payloadAddress: `0x${string}`,
+  addresses: L1ContractAddresses,
+  privateKey: PrivateKeyAccount,
+  publicClient: L1Clients['publicClient'],
+  logger: Logger,
+): Promise<{ governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>; voteAmount: bigint }> {
+  const token = getContract({
+    address: addresses.feeJuiceAddress.toString(),
+    abi: FeeJuiceAbi,
+    client: publicClient,
+  });
+
+  const governance = getContract({
+    address: addresses.governanceAddress.toString(),
+    abi: GovernanceAbi,
+    client: publicClient,
+  });
+
+  const lockAmount = 10000n * 10n ** 18n;
+  const voteAmount = 10000n * 10n ** 18n;
+
+  const mintTx = await token.write.mint([privateKey.address, lockAmount + voteAmount], { account: privateKey });
+  await publicClient.waitForTransactionReceipt({ hash: mintTx });
+  logger.info(`Minted tokens`);
+
+  const approveTx = await token.write.approve([addresses.governanceAddress.toString(), lockAmount + voteAmount], {
+    account: privateKey,
+  });
+  await publicClient.waitForTransactionReceipt({ hash: approveTx });
+  logger.info(`Approved tokens`);
+
+  const depositTx = await governance.write.deposit([privateKey.address, lockAmount + voteAmount], {
+    account: privateKey,
+  });
+  await publicClient.waitForTransactionReceipt({ hash: depositTx });
+  logger.info(`Deposited tokens`);
+
+  await governance.write.proposeWithLock([payloadAddress, privateKey.address], {
+    account: privateKey,
+  });
+
+  return { governance, voteAmount };
+}

package/src/types.ts

@@ -0,0 +1,33 @@
+import type {
+  Account,
+  Chain,
+  Client,
+  FallbackTransport,
+  HttpTransport,
+  PublicActions,
+  PublicClient,
+  PublicRpcSchema,
+  WalletActions,
+  WalletClient,
+  WalletRpcSchema,
+} from 'viem';
+
+/** Type for a viem public client */
+export type ViemPublicClient = PublicClient<FallbackTransport<HttpTransport[]>, Chain>;
+
+export type SimpleViemWalletClient = WalletClient<FallbackTransport<HttpTransport[]>, Chain, Account>;
+
+export type ExtendedViemWalletClient = Client<
+  FallbackTransport<readonly HttpTransport[]>,
+  Chain,
+  Account,
+  [...PublicRpcSchema, ...WalletRpcSchema],
+  PublicActions<FallbackTransport<readonly HttpTransport[]>, Chain> & WalletActions<Chain, Account>
+>;
+
+export type ViemWalletClient = SimpleViemWalletClient | ExtendedViemWalletClient;
+
+export type L1Clients = {
+  publicClient: ViemPublicClient;
+  walletClient: ExtendedViemWalletClient;
+};