@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.21caa21

package/dest/l1_tx_utils_with_blobs.js

@@ -1,64 +0,0 @@
-import { Blob } from '@aztec/blob-lib';
-import { formatGwei } from 'viem';
-import { 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
-   */ async attemptTxCancellation(nonce, isBlobTx = false, previousGasPrice, 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
-        }, 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,
-                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/contracts/forwarder.ts

@@ -1,132 +0,0 @@
-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/slashing_proposer.ts

@@ -1,51 +0,0 @@
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { SlashingProposerAbi } from '@aztec/l1-artifacts';
-
-import { type GetContractReturnType, type Hex, getContract } from 'viem';
-
-import type { L1TxRequest } from '../l1_tx_utils.js';
-import type { ViemPublicClient } from '../types.js';
-import { type IEmpireBase, encodeVote } from './empire_base.js';
-
-export class SlashingProposerContract implements IEmpireBase {
-  private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, ViemPublicClient>;
-
-  constructor(public readonly client: ViemPublicClient, address: Hex) {
-    this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
-  }
-
-  public get address() {
-    return EthAddress.fromString(this.proposer.address);
-  }
-
-  public getQuorumSize() {
-    return this.proposer.read.N();
-  }
-
-  public getRoundSize() {
-    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 createVoteRequest(payload: Hex): L1TxRequest {
-    return {
-      to: this.address.toString(),
-      data: encodeVote(payload),
-    };
-  }
-}

package/src/eth_cheat_codes.ts

@@ -1,314 +0,0 @@
-import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { createLogger } from '@aztec/foundation/log';
-
-import { type Hex, createPublicClient, fallback, http } from 'viem';
-
-import type { ViemPublicClient } from './types.js';
-
-/**
- * A class that provides utility functions for interacting with ethereum (L1).
- */
-export class EthCheatCodes {
-  private publicClient: ViemPublicClient;
-  constructor(
-    /**
-     * The RPC URL to use for interacting with the chain
-     */
-    public rpcUrls: string[],
-    /**
-     * The logger to use for the eth cheatcodes
-     */
-    public logger = createLogger('ethereum:cheat_codes'),
-  ) {
-    this.publicClient = createPublicClient({
-      transport: fallback(this.rpcUrls.map(url => http(url))),
-    });
-  }
-
-  async rpcCall(method: string, params: any[]) {
-    const paramsString = JSON.stringify(params);
-    this.logger.info(`Calling ${method} with params: ${paramsString} on ${this.rpcUrls.join(', ')}`);
-    return (await this.publicClient.transport.request({
-      method,
-      params,
-    })) as any;
-  }
-
-  /**
-   * Get the auto mine status of the underlying chain
-   * @returns True if automine is on, false otherwise
-   */
-  public async isAutoMining(): Promise<boolean> {
-    try {
-      const res = await this.rpcCall('anvil_getAutomine', []);
-      return res;
-    } catch (err) {
-      this.logger.error(`Calling "anvil_getAutomine" failed with:`, err);
-    }
-    return false;
-  }
-
-  /**
-   * Get the current blocknumber
-   * @returns The current block number
-   */
-  public async blockNumber(): Promise<number> {
-    const res = await this.rpcCall('eth_blockNumber', []);
-    return parseInt(res, 16);
-  }
-
-  /**
-   * Get the current chainId
-   * @returns The current chainId
-   */
-  public async chainId(): Promise<number> {
-    const res = await this.rpcCall('eth_chainId', []);
-    return parseInt(res, 16);
-  }
-
-  /**
-   * Get the current timestamp
-   * @returns The current timestamp
-   */
-  public async timestamp(): Promise<number> {
-    const res = await this.rpcCall('eth_getBlockByNumber', ['latest', true]);
-    return parseInt(res.timestamp, 16);
-  }
-
-  /**
-   * Advance the chain by a number of blocks
-   * @param numberOfBlocks - The number of blocks to mine
-   */
-  public async mine(numberOfBlocks = 1): Promise<void> {
-    await this.doMine(numberOfBlocks);
-    this.logger.warn(`Mined ${numberOfBlocks} L1 blocks`);
-  }
-
-  private async doMine(numberOfBlocks = 1): Promise<void> {
-    try {
-      await this.rpcCall('hardhat_mine', [numberOfBlocks]);
-    } catch (err) {
-      throw new Error(`Error mining: ${err}`);
-    }
-  }
-
-  /**
-   * Mines a single block with evm_mine
-   */
-  public async evmMine(): Promise<void> {
-    try {
-      await this.rpcCall('evm_mine', []);
-    } catch (err) {
-      throw new Error(`Error mining: ${err}`);
-    }
-  }
-
-  /**
-   * Set the balance of an account
-   * @param account - The account to set the balance for
-   * @param balance - The balance to set
-   */
-  public async setBalance(account: EthAddress, balance: bigint): Promise<void> {
-    try {
-      await this.rpcCall('anvil_setBalance', [account.toString(), toHex(balance)]);
-    } catch (err) {
-      throw new Error(`Error setting balance for ${account}: ${err}`);
-    }
-    this.logger.warn(`Set balance for ${account} to ${balance}`);
-  }
-
-  /**
-   * Set the interval between blocks (block time)
-   * @param interval - The interval to use between blocks
-   */
-  public async setBlockInterval(interval: number): Promise<void> {
-    try {
-      await this.rpcCall('anvil_setBlockTimestampInterval', [interval]);
-    } catch (err) {
-      throw new Error(`Error setting block interval: ${err}`);
-    }
-    this.logger.warn(`Set L1 block interval to ${interval}`);
-  }
-
-  /**
-   * Set the next block base fee per gas
-   * @param baseFee - The base fee to set
-   */
-  public async setNextBlockBaseFeePerGas(baseFee: bigint | number): Promise<void> {
-    try {
-      await this.rpcCall('anvil_setNextBlockBaseFeePerGas', [baseFee.toString()]);
-    } catch (err) {
-      throw new Error(`Error setting next block base fee per gas: ${err}`);
-    }
-    this.logger.warn(`Set L1 next block base fee per gas to ${baseFee}`);
-  }
-
-  /**
-   * Set the interval between blocks (block time)
-   * @param seconds - The interval to use between blocks
-   */
-  public async setIntervalMining(seconds: number): Promise<void> {
-    try {
-      await this.rpcCall('anvil_setIntervalMining', [seconds]);
-    } catch (err) {
-      throw new Error(`Error setting interval mining: ${err}`);
-    }
-    this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
-  }
-
-  /**
-   * Set the automine status of the underlying anvil chain
-   * @param automine - The automine status to set
-   */
-  public async setAutomine(automine: boolean): Promise<void> {
-    try {
-      await this.rpcCall('anvil_setAutomine', [automine]);
-    } catch (err) {
-      throw new Error(`Error setting automine: ${err}`);
-    }
-    this.logger.warn(`Set L1 automine to ${automine}`);
-  }
-
-  /**
-   * Drop a transaction from the mempool
-   * @param txHash - The transaction hash
-   */
-  public async dropTransaction(txHash: Hex): Promise<void> {
-    try {
-      await this.rpcCall('anvil_dropTransaction', [txHash]);
-    } catch (err) {
-      throw new Error(`Error dropping transaction: ${err}`);
-    }
-    this.logger.warn(`Dropped transaction ${txHash}`);
-  }
-
-  /**
-   * Set the next block timestamp
-   * @param timestamp - The timestamp to set the next block to
-   */
-  public async setNextBlockTimestamp(timestamp: number): Promise<void> {
-    try {
-      await this.rpcCall('evm_setNextBlockTimestamp', [timestamp]);
-    } catch (err: any) {
-      throw new Error(`Error setting next block timestamp: ${err.message}`);
-    }
-    this.logger.warn(`Set L1 next block timestamp to ${timestamp}`);
-  }
-
-  /**
-   * Set the next block timestamp and mines the block
-   * @param timestamp - The timestamp to set the next block to
-   */
-  public async warp(timestamp: number | bigint, silent = false): Promise<void> {
-    try {
-      await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
-    } catch (err) {
-      throw new Error(`Error warping: ${err}`);
-    }
-    await this.doMine();
-    if (!silent) {
-      this.logger.warn(`Warped L1 timestamp to ${timestamp}`);
-    }
-  }
-
-  /**
-   * Load the value at a storage slot of a contract address on eth
-   * @param contract - The contract address
-   * @param slot - The storage slot
-   * @returns - The value at the storage slot
-   */
-  public async load(contract: EthAddress, slot: bigint): Promise<bigint> {
-    const res = await this.rpcCall('eth_getStorageAt', [contract.toString(), toHex(slot), 'latest']);
-    return BigInt(res);
-  }
-
-  /**
-   * Set the value at a storage slot of a contract address on eth
-   * @param contract - The contract address
-   * @param slot - The storage slot
-   * @param value - The value to set the storage slot to
-   */
-  public async store(contract: EthAddress, slot: bigint, value: bigint): Promise<void> {
-    // for the rpc call, we need to change value to be a 32 byte hex string.
-    try {
-      await this.rpcCall('hardhat_setStorageAt', [contract.toString(), toHex(slot), toHex(value, true)]);
-    } catch (err) {
-      throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${err}`);
-    }
-    this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
-  }
-
-  /**
-   * Computes the slot value for a given map and key.
-   * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
-   * @param key - The key to lookup in the map
-   * @returns The storage slot of the value in the map
-   */
-  public keccak256(baseSlot: bigint, key: bigint): bigint {
-    // abi encode (removing the 0x) - concat key and baseSlot (both padded to 32 bytes)
-    const abiEncoded = toHex(key, true).substring(2) + toHex(baseSlot, true).substring(2);
-    return toBigIntBE(keccak256(Buffer.from(abiEncoded, 'hex')));
-  }
-
-  /**
-   * Send transactions impersonating an externally owned account or contract.
-   * @param who - The address to impersonate
-   */
-  public async startImpersonating(who: EthAddress | Hex): Promise<void> {
-    try {
-      await this.rpcCall('hardhat_impersonateAccount', [who.toString()]);
-    } catch (err) {
-      throw new Error(`Error impersonating ${who}: ${err}`);
-    }
-    this.logger.warn(`Impersonating ${who}`);
-  }
-
-  /**
-   * Stop impersonating an account that you are currently impersonating.
-   * @param who - The address to stop impersonating
-   */
-  public async stopImpersonating(who: EthAddress | Hex): Promise<void> {
-    try {
-      await this.rpcCall('hardhat_stopImpersonatingAccount', [who.toString()]);
-    } catch (err) {
-      throw new Error(`Error when stopping the impersonation of ${who}: ${err}`);
-    }
-    this.logger.warn(`Stopped impersonating ${who}`);
-  }
-
-  /**
-   * Set the bytecode for a contract
-   * @param contract - The contract address
-   * @param bytecode - The bytecode to set
-   */
-  public async etch(contract: EthAddress, bytecode: `0x${string}`): Promise<void> {
-    try {
-      await this.rpcCall('hardhat_setCode', [contract.toString(), bytecode]);
-    } catch (err) {
-      throw new Error(`Error setting bytecode for ${contract}: ${err}`);
-    }
-    this.logger.warn(`Set bytecode for ${contract} to ${bytecode}`);
-  }
-
-  /**
-   * Get the bytecode for a contract
-   * @param contract - The contract address
-   * @returns The bytecode for the contract
-   */
-  public async getBytecode(contract: EthAddress): Promise<`0x${string}`> {
-    const res = await this.rpcCall('eth_getCode', [contract.toString(), 'latest']);
-    return res;
-  }
-
-  /**
-   * Get the raw transaction object for a given transaction hash
-   * @param txHash - The transaction hash
-   * @returns The raw transaction
-   */
-  public async getRawTransaction(txHash: Hex): Promise<`0x${string}`> {
-    const res = await this.rpcCall('debug_getRawTransaction', [txHash]);
-    return res;
-  }
-}