@aztec/ethereum 0.65.2 → 0.66.0

package/src/deploy_l1_contracts.ts

@@ -5,6 +5,8 @@ import { type DebugLogger } from '@aztec/foundation/log';
 import {
   CoinIssuerAbi,
   CoinIssuerBytecode,
+  ExtRollupLibAbi,
+  ExtRollupLibBytecode,
   FeeJuicePortalAbi,
   FeeJuicePortalBytecode,
   GovernanceAbi,
@@ -13,6 +15,8 @@ import {
   GovernanceProposerBytecode,
   InboxAbi,
   InboxBytecode,
+  LeonidasLibAbi,
+  LeonidasLibBytecode,
   OutboxAbi,
   OutboxBytecode,
   RegistryAbi,
@@ -22,12 +26,8 @@ import {
   RollupAbi,
   RollupBytecode,
   RollupLinkReferences,
-  SampleLibAbi,
-  SampleLibBytecode,
   TestERC20Abi,
   TestERC20Bytecode,
-  TxsDecoderAbi,
-  TxsDecoderBytecode,
 } from '@aztec/l1-artifacts';
 
 import type { Abi, Narrow } from 'abitype';
@@ -53,8 +53,10 @@ import { type HDAccount, type PrivateKeyAccount, mnemonicToAccount, privateKeyTo
 import { foundry } from 'viem/chains';
 
 import { type L1ContractsConfig } from './config.js';
+import { MINIMUM_STAKE } from './constants.js';
 import { isAnvilTestChain } from './ethereum_chain.js';
 import { type L1ContractAddresses } from './l1_contract_addresses.js';
+import { L1TxUtils } from './l1_tx_utils.js';
 
 /**
  * Return type of the deployL1Contract function.
@@ -126,10 +128,14 @@ export interface L1ContractArtifactsForDeployment {
    * Rollup contract artifacts
    */
   rollup: ContractArtifacts;
+  /**
+   * The token to stake.
+   */
+  stakingAsset: ContractArtifacts;
   /**
    * The token to pay for gas. This will be bridged to L2 via the feeJuicePortal below
    */
-  feeJuice: ContractArtifacts;
+  feeAsset: ContractArtifacts;
   /**
    * Fee juice portal contract artifacts. Optional for now as gas is not strictly enforced
    */
@@ -171,18 +177,22 @@ export const l1Artifacts: L1ContractArtifactsForDeployment = {
     libraries: {
       linkReferences: RollupLinkReferences,
       libraryCode: {
-        TxsDecoder: {
-          contractAbi: TxsDecoderAbi,
-          contractBytecode: TxsDecoderBytecode,
+        LeonidasLib: {
+          contractAbi: LeonidasLibAbi,
+          contractBytecode: LeonidasLibBytecode,
         },
-        SampleLib: {
-          contractAbi: SampleLibAbi,
-          contractBytecode: SampleLibBytecode,
+        ExtRollupLib: {
+          contractAbi: ExtRollupLibAbi,
+          contractBytecode: ExtRollupLibBytecode,
         },
       },
     },
   },
-  feeJuice: {
+  stakingAsset: {
+    contractAbi: TestERC20Abi,
+    contractBytecode: TestERC20Bytecode,
+  },
+  feeAsset: {
     contractAbi: TestERC20Abi,
     contractBytecode: TestERC20Bytecode,
   },
@@ -255,6 +265,7 @@ export function createL1Clients(
   const publicClient = createPublicClient({
     chain,
     transport: http(rpcUrl),
+    pollingInterval: 100,
   });
 
   return { walletClient, publicClient };
@@ -306,8 +317,19 @@ export const deployL1Contracts = async (
   const registryAddress = await govDeployer.deploy(l1Artifacts.registry, [account.address.toString()]);
   logger.info(`Deployed Registry at ${registryAddress}`);
 
-  const feeJuiceAddress = await govDeployer.deploy(l1Artifacts.feeJuice);
-  logger.info(`Deployed Fee Juice at ${feeJuiceAddress}`);
+  const feeAssetAddress = await govDeployer.deploy(l1Artifacts.feeAsset, [
+    'FeeJuice',
+    'FEE',
+    account.address.toString(),
+  ]);
+  logger.info(`Deployed Fee Juice at ${feeAssetAddress}`);
+
+  const stakingAssetAddress = await govDeployer.deploy(l1Artifacts.stakingAsset, [
+    'Staking',
+    'STK',
+    account.address.toString(),
+  ]);
+  logger.info(`Deployed Staking Asset at ${stakingAssetAddress}`);
 
   // @todo  #8084
   // @note These numbers are just chosen to make testing simple.
@@ -320,26 +342,29 @@ export const deployL1Contracts = async (
   ]);
   logger.info(`Deployed GovernanceProposer at ${governanceProposerAddress}`);
 
+  // @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 govDeployer.deploy(l1Artifacts.governance, [
-    feeJuiceAddress.toString(),
+    feeAssetAddress.toString(),
     governanceProposerAddress.toString(),
   ]);
   logger.info(`Deployed Governance at ${governanceAddress}`);
 
   const coinIssuerAddress = await govDeployer.deploy(l1Artifacts.coinIssuer, [
-    feeJuiceAddress.toString(),
+    feeAssetAddress.toString(),
     1n * 10n ** 18n, // @todo  #8084
     governanceAddress.toString(),
   ]);
   logger.info(`Deployed CoinIssuer at ${coinIssuerAddress}`);
 
   const rewardDistributorAddress = await govDeployer.deploy(l1Artifacts.rewardDistributor, [
-    feeJuiceAddress.toString(),
+    feeAssetAddress.toString(),
     registryAddress.toString(),
     governanceAddress.toString(),
   ]);
   logger.info(`Deployed RewardDistributor at ${rewardDistributorAddress}`);
 
+  logger.verbose(`Waiting for governance contracts to be deployed`);
   await govDeployer.waitForDeployments();
   logger.info(`All governance contracts deployed`);
 
@@ -347,27 +372,29 @@ export const deployL1Contracts = async (
 
   const feeJuicePortalAddress = await deployer.deploy(l1Artifacts.feeJuicePortal, [
     registryAddress.toString(),
-    feeJuiceAddress.toString(),
+    feeAssetAddress.toString(),
     args.l2FeeJuiceAddress.toString(),
   ]);
   logger.info(`Deployed Fee Juice Portal at ${feeJuicePortalAddress}`);
 
-  const rollupArgs = {
+  const rollupConfigArgs = {
     aztecSlotDuration: args.aztecSlotDuration,
     aztecEpochDuration: args.aztecEpochDuration,
     targetCommitteeSize: args.aztecTargetCommitteeSize,
     aztecEpochProofClaimWindowInL2Slots: args.aztecEpochProofClaimWindowInL2Slots,
+    minimumStake: MINIMUM_STAKE,
   };
-  const rollupAddress = await deployer.deploy(l1Artifacts.rollup, [
+  const rollupArgs = [
     feeJuicePortalAddress.toString(),
     rewardDistributorAddress.toString(),
+    stakingAssetAddress.toString(),
     args.vkTreeRoot.toString(),
     args.protocolContractTreeRoot.toString(),
     account.address.toString(),
-    args.initialValidators?.map(v => v.toString()) ?? [],
-    rollupArgs,
-  ]);
-  logger.info(`Deployed Rollup at ${rollupAddress}`, rollupArgs);
+    rollupConfigArgs,
+  ];
+  const rollupAddress = await deployer.deploy(l1Artifacts.rollup, rollupArgs);
+  logger.info(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
 
   await deployer.waitForDeployments();
   logger.info(`All core contracts deployed`);
@@ -378,9 +405,15 @@ export const deployL1Contracts = async (
     client: walletClient,
   });
 
-  const feeJuice = getContract({
-    address: feeJuiceAddress.toString(),
-    abi: l1Artifacts.feeJuice.contractAbi,
+  const feeAsset = getContract({
+    address: feeAssetAddress.toString(),
+    abi: l1Artifacts.feeAsset.contractAbi,
+    client: walletClient,
+  });
+
+  const stakingAsset = getContract({
+    address: stakingAssetAddress.toString(),
+    abi: l1Artifacts.stakingAsset.contractAbi,
     client: walletClient,
   });
 
@@ -393,12 +426,40 @@ export const deployL1Contracts = async (
   // Transaction hashes to await
   const txHashes: Hex[] = [];
 
+  {
+    const txHash = await feeAsset.write.setFreeForAll([true], {} as any);
+    logger.info(`Fee asset set to free for all in ${txHash}`);
+    txHashes.push(txHash);
+  }
+
+  if (args.initialValidators && args.initialValidators.length > 0) {
+    // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
+    const stakeNeeded = MINIMUM_STAKE * BigInt(args.initialValidators.length);
+    await Promise.all(
+      [
+        await stakingAsset.write.mint([walletClient.account.address, stakeNeeded], {} as any),
+        await stakingAsset.write.approve([rollupAddress.toString(), stakeNeeded], {} as any),
+      ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+    );
+
+    const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([
+      args.initialValidators.map(v => ({
+        attester: v.toString(),
+        proposer: v.toString(),
+        withdrawer: v.toString(),
+        amount: MINIMUM_STAKE,
+      })),
+    ]);
+    txHashes.push(initiateValidatorSetTxHash);
+    logger.info(`Initialized validator set (${args.initialValidators.join(', ')}) in tx ${initiateValidatorSetTxHash}`);
+  }
+
   // @note  This value MUST match what is in `constants.nr`. It is currently specified here instead of just importing
   //        because there is circular dependency hell. This is a temporary solution. #3342
   // @todo  #8084
   // fund the portal contract with Fee Juice
-  const FEE_JUICE_INITIAL_MINT = 200000000000000000000;
-  const mintTxHash = await feeJuice.write.mint([feeJuicePortalAddress.toString(), FEE_JUICE_INITIAL_MINT], {} as any);
+  const FEE_JUICE_INITIAL_MINT = 200000000000000000000n;
+  const mintTxHash = await feeAsset.write.mint([feeJuicePortalAddress.toString(), FEE_JUICE_INITIAL_MINT], {} as any);
 
   // @note  This is used to ensure we fully wait for the transaction when running against a real chain
   //        otherwise we execute subsequent transactions too soon
@@ -414,7 +475,7 @@ export const deployL1Contracts = async (
   }
 
   logger.info(
-    `Initialized Fee Juice Portal at ${feeJuicePortalAddress} to bridge between L1 ${feeJuiceAddress} to L2 ${args.l2FeeJuiceAddress}`,
+    `Initialized Fee Juice Portal at ${feeJuicePortalAddress} to bridge between L1 ${feeAssetAddress} to L2 ${args.l2FeeJuiceAddress}`,
   );
 
   if (isAnvilTestChain(chain.id)) {
@@ -492,7 +553,8 @@ export const deployL1Contracts = async (
     registryAddress,
     inboxAddress,
     outboxAddress,
-    feeJuiceAddress,
+    feeJuiceAddress: feeAssetAddress,
+    stakingAssetAddress,
     feeJuicePortalAddress,
     coinIssuerAddress,
     rewardDistributorAddress,
@@ -607,10 +669,21 @@ export async function deployL1Contract(
   logger?: DebugLogger,
 ): Promise<{ address: EthAddress; txHash: Hex | undefined }> {
   let txHash: Hex | undefined = undefined;
-  let address: Hex | null | undefined = undefined;
+  let resultingAddress: Hex | null | undefined = undefined;
+
+  const l1TxUtils = new L1TxUtils(publicClient, walletClient, logger);
 
   if (libraries) {
-    // @note  Assumes that we wont have nested external libraries.
+    // Note that this does NOT work well for linked libraries having linked libraries.
+
+    // Verify that all link references have corresponding code
+    for (const linkRef in libraries.linkReferences) {
+      for (const contractName in libraries.linkReferences[linkRef]) {
+        if (!libraries.libraryCode[contractName]) {
+          throw new Error(`Missing library code for ${contractName}`);
+        }
+      }
+    }
 
     const replacements: Record<string, EthAddress> = {};
 
@@ -659,21 +732,31 @@ export async function deployL1Contract(
     const salt = padHex(maybeSalt, { size: 32 });
     const deployer: Hex = '0x4e59b44847b379578588920cA78FbF26c0B4956C';
     const calldata = encodeDeployData({ abi, bytecode, args });
-    address = getContractAddress({ from: deployer, salt, bytecode: calldata, opcode: 'CREATE2' });
-    const existing = await publicClient.getBytecode({ address });
+    resultingAddress = getContractAddress({ from: deployer, salt, bytecode: calldata, opcode: 'CREATE2' });
+    const existing = await publicClient.getBytecode({ address: resultingAddress });
 
     if (existing === undefined || existing === '0x') {
-      txHash = await walletClient.sendTransaction({ to: deployer, data: concatHex([salt, calldata]) });
-      logger?.verbose(`Deploying contract with salt ${salt} to address ${address} in tx ${txHash}`);
+      const res = await l1TxUtils.sendTransaction({
+        to: deployer,
+        data: concatHex([salt, calldata]),
+      });
+      txHash = res.txHash;
+
+      logger?.verbose(`Deployed contract with salt ${salt} to address ${resultingAddress} in tx ${txHash}.`);
     } else {
-      logger?.verbose(`Skipping existing deployment of contract with salt ${salt} to address ${address}`);
+      logger?.verbose(`Skipping existing deployment of contract with salt ${salt} to address ${resultingAddress}`);
     }
   } else {
-    txHash = await walletClient.deployContract({ abi, bytecode, args });
-    logger?.verbose(`Deploying contract in tx ${txHash}`);
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash, pollingInterval: 100 });
-    address = receipt.contractAddress;
-    if (!address) {
+    // Regular deployment path
+    const deployData = encodeDeployData({ abi, bytecode, args });
+    const receipt = await l1TxUtils.sendAndMonitorTransaction({
+      to: null,
+      data: deployData,
+    });
+
+    txHash = receipt.transactionHash;
+    resultingAddress = receipt.contractAddress;
+    if (!resultingAddress) {
       throw new Error(
         `No contract address found in receipt: ${JSON.stringify(receipt, (_, val) =>
           typeof val === 'bigint' ? String(val) : val,
@@ -682,6 +765,6 @@ export async function deployL1Contract(
     }
   }
 
-  return { address: EthAddress.fromString(address!), txHash };
+  return { address: EthAddress.fromString(resultingAddress!), txHash };
 }
 // docs:end:deployL1Contract

package/src/eth_cheat_codes.ts

@@ -0,0 +1,316 @@
+import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { type EthAddress } from '@aztec/foundation/eth-address';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import fs from 'fs';
+import { type Hex } from 'viem';
+
+/**
+ * A class that provides utility functions for interacting with ethereum (L1).
+ */
+export class EthCheatCodes {
+  constructor(
+    /**
+     * The RPC URL to use for interacting with the chain
+     */
+    public rpcUrl: string,
+    /**
+     * The logger to use for the eth cheatcodes
+     */
+    public logger = createDebugLogger('aztec:cheat_codes:eth'),
+  ) {}
+
+  async rpcCall(method: string, params: any[]) {
+    const paramsString = JSON.stringify(params);
+    const content = {
+      body: `{"jsonrpc":"2.0", "method": "${method}", "params": ${paramsString}, "id": 1}`,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    };
+    return await (await fetch(this.rpcUrl, content)).json();
+  }
+
+  /**
+   * 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.result;
+    } 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.result, 16);
+  }
+
+  /**
+   * Get the current chainId
+   * @returns The current chainId
+   */
+  public async chainId(): Promise<number> {
+    const res = await this.rpcCall('eth_chainId', []);
+    return parseInt(res.result, 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.result.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> {
+    const res = await this.rpcCall('hardhat_mine', [numberOfBlocks]);
+    if (res.error) {
+      throw new Error(`Error mining: ${res.error.message}`);
+    }
+    this.logger.verbose(`Mined ${numberOfBlocks} L1 blocks`);
+  }
+
+  /**
+   * Mines a single block with evm_mine
+   */
+  public async evmMine(): Promise<void> {
+    const res = await this.rpcCall('evm_mine', []);
+    if (res.error) {
+      throw new Error(`Error mining: ${res.error.message}`);
+    }
+  }
+
+  /**
+   * 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> {
+    const res = await this.rpcCall('anvil_setBalance', [account.toString(), toHex(balance)]);
+    if (res.error) {
+      throw new Error(`Error setting balance for ${account}: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('anvil_setBlockTimestampInterval', [interval]);
+    if (res.error) {
+      throw new Error(`Error setting block interval: ${res.error.message}`);
+    }
+    this.logger.verbose(`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): Promise<void> {
+    const res = await this.rpcCall('anvil_setNextBlockBaseFeePerGas', [baseFee.toString()]);
+    if (res.error) {
+      throw new Error(`Error setting next block base fee per gas: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('anvil_setIntervalMining', [seconds]);
+    if (res.error) {
+      throw new Error(`Error setting interval mining: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('anvil_setAutomine', [automine]);
+    if (res.error) {
+      throw new Error(`Error setting automine: ${res.error.message}`);
+    }
+    this.logger.verbose(`Set L1 automine to ${automine}`);
+  }
+
+  /**
+   * Drop a transaction from the mempool
+   * @param txHash - The transaction hash
+   */
+  public async dropTransaction(txHash: Hex): Promise<void> {
+    const res = await this.rpcCall('anvil_dropTransaction', [txHash]);
+    if (res.error) {
+      throw new Error(`Error dropping transaction: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('evm_setNextBlockTimestamp', [timestamp]);
+    if (res.error) {
+      throw new Error(`Error setting next block timestamp: ${res.error.message}`);
+    }
+    this.logger.verbose(`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): Promise<void> {
+    const res = await this.rpcCall('evm_setNextBlockTimestamp', [Number(timestamp)]);
+    if (res.error) {
+      throw new Error(`Error warping: ${res.error.message}`);
+    }
+    await this.mine();
+    this.logger.verbose(`Warped L1 timestamp to ${timestamp}`);
+  }
+
+  /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */
+  public async dumpChainState(fileName: string): Promise<void> {
+    const res = await this.rpcCall('hardhat_dumpState', []);
+    if (res.error) {
+      throw new Error(`Error dumping state: ${res.error.message}`);
+    }
+    const jsonContent = JSON.stringify(res.result);
+    fs.writeFileSync(`${fileName}.json`, jsonContent, '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'));
+    const res = await this.rpcCall('hardhat_loadState', [data]);
+    if (res.error) {
+      throw new Error(`Error loading state: ${res.error.message}`);
+    }
+    this.logger.verbose(`Loaded state from ${fileName}`);
+  }
+
+  /**
+   * 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.result);
+  }
+
+  /**
+   * 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.
+    const res = await this.rpcCall('hardhat_setStorageAt', [contract.toString(), toHex(slot), toHex(value, true)]);
+    if (res.error) {
+      throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('hardhat_impersonateAccount', [who.toString()]);
+    if (res.error) {
+      throw new Error(`Error impersonating ${who}: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('hardhat_stopImpersonatingAccount', [who.toString()]);
+    if (res.error) {
+      throw new Error(`Error when stopping the impersonation of ${who}: ${res.error.message}`);
+    }
+    this.logger.verbose(`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> {
+    const res = await this.rpcCall('hardhat_setCode', [contract.toString(), bytecode]);
+    if (res.error) {
+      throw new Error(`Error setting bytecode for ${contract}: ${res.error.message}`);
+    }
+    this.logger.verbose(`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.result;
+  }
+
+  /**
+   * 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.result;
+  }
+}

package/src/index.ts

@@ -1,8 +1,11 @@
 export * from './constants.js';
 export * from './deploy_l1_contracts.js';
+export * from './ethereum_chain.js';
+export * from './eth_cheat_codes.js';
+export * from './l1_tx_utils.js';
 export * from './l1_contract_addresses.js';
 export * from './l1_reader.js';
-export * from './ethereum_chain.js';
 export * from './utils.js';
 export * from './config.js';
 export * from './types.js';
+export * from './contracts/index.js';

package/src/l1_contract_addresses.ts

@@ -20,6 +20,7 @@ export const L1ContractsNames = [
   'rewardDistributorAddress',
   'governanceProposerAddress',
   'governanceAddress',
+  'stakingAssetAddress',
 ] as const;
 
 /** Provides the directory of current L1 contract addresses */
@@ -33,6 +34,7 @@ export const L1ContractAddressesSchema = z.object({
   inboxAddress: schemas.EthAddress,
   outboxAddress: schemas.EthAddress,
   feeJuiceAddress: schemas.EthAddress,
+  stakingAssetAddress: schemas.EthAddress,
   feeJuicePortalAddress: schemas.EthAddress,
   coinIssuerAddress: schemas.EthAddress,
   rewardDistributorAddress: schemas.EthAddress,
@@ -68,6 +70,11 @@ export const l1ContractAddressesMapping: ConfigMappingsType<L1ContractAddresses>
     description: 'The deployed L1 Fee Juice contract address.',
     parseEnv,
   },
+  stakingAssetAddress: {
+    env: 'STAKING_ASSET_CONTRACT_ADDRESS',
+    description: 'The deployed L1 staking asset contract address.',
+    parseEnv,
+  },
   feeJuicePortalAddress: {
     env: 'FEE_JUICE_PORTAL_CONTRACT_ADDRESS',
     description: 'The deployed L1 Fee Juice portal contract address.',