@aztec/ethereum 0.0.0-test.0

package/dest/utils.js

@@ -0,0 +1,209 @@
+import { ErrorsAbi } from '@aztec/l1-artifacts';
+import { BaseError, ContractFunctionRevertedError, decodeErrorResult, decodeEventLog } from 'viem';
+export class FormattedViemError extends Error {
+    metaMessages;
+    constructor(message, metaMessages){
+        super(message);
+        this.name = 'FormattedViemError';
+        this.metaMessages = metaMessages;
+    }
+}
+export function extractEvent(logs, address, abi, eventName, filter, logger) {
+    const event = tryExtractEvent(logs, address, abi, eventName, filter, logger);
+    if (!event) {
+        throw new Error(`Failed to find matching event ${eventName} for contract ${address}`);
+    }
+    return event;
+}
+function tryExtractEvent(logs, address, abi, eventName, filter, logger) {
+    for (const log of logs){
+        if (log.address.toLowerCase() === address.toLowerCase()) {
+            try {
+                const decodedEvent = decodeEventLog({
+                    abi,
+                    ...log
+                });
+                if (decodedEvent.eventName === eventName) {
+                    const matchingEvent = decodedEvent;
+                    if (!filter || filter(matchingEvent)) {
+                        return matchingEvent;
+                    }
+                }
+            } catch (err) {
+                logger?.warn(`Failed to decode event log for contract ${address}: ${err}`);
+            }
+        }
+    }
+}
+export function prettyLogViemErrorMsg(err) {
+    if (err instanceof BaseError) {
+        const revertError = err.walk((err)=>err instanceof ContractFunctionRevertedError);
+        if (revertError instanceof ContractFunctionRevertedError) {
+            const errorName = revertError.data?.errorName ?? '';
+            const args = revertError.metaMessages && revertError.metaMessages?.length > 1 ? revertError.metaMessages[1].trimStart() : '';
+            return `${errorName}${args}`;
+        }
+    }
+    return err?.message ?? err;
+}
+function getNestedErrorData(error) {
+    // If nothing, bail
+    if (!error) {
+        return undefined;
+    }
+    // If it's an object with a `data` property, return it
+    // (Remember to check TS type-safely or cast as needed)
+    if (typeof error === 'object' && error !== null && 'data' in error) {
+        const possibleData = error.data;
+        if (typeof possibleData === 'string' && possibleData.startsWith('0x')) {
+            return possibleData;
+        }
+    }
+    // If it has a `cause`, recurse
+    if (typeof error === 'object' && error !== null && 'cause' in error) {
+        return getNestedErrorData(error.cause);
+    }
+    // Not found
+    return undefined;
+}
+/**
+ * Formats a Viem error into a FormattedViemError instance.
+ * @param error - The error to format.
+ * @param abi - The ABI to use for decoding.
+ * @returns A FormattedViemError instance.
+ */ export function formatViemError(error, abi = ErrorsAbi) {
+    // If error is already a FormattedViemError, return it as is
+    if (error instanceof FormattedViemError) {
+        return error;
+    }
+    // First try to decode as a custom error using the ABI
+    try {
+        const data = getNestedErrorData(error);
+        if (data) {
+            // Try to decode the error data using the ABI
+            const decoded = decodeErrorResult({
+                abi,
+                data: data
+            });
+            if (decoded) {
+                return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages);
+            }
+        }
+        // If it's a BaseError, try to get the custom error through ContractFunctionRevertedError
+        if (error instanceof BaseError) {
+            const revertError = error.walk((err)=>err instanceof ContractFunctionRevertedError);
+            if (revertError instanceof ContractFunctionRevertedError) {
+                let errorName = revertError.data?.errorName;
+                if (!errorName) {
+                    errorName = revertError.signature ?? '';
+                }
+                const args = revertError.metaMessages && revertError.metaMessages?.length > 1 ? revertError.metaMessages[1].trimStart() : '';
+                return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
+            }
+        }
+    } catch (decodeErr) {
+    // If decoding fails, we fall back to the original formatting
+    }
+    // If it's a regular Error instance, return it with its message
+    if (error instanceof Error) {
+        return error;
+    }
+    // Original formatting logic for non-custom errors
+    const truncateHex = (hex, length = 100)=>{
+        if (!hex || typeof hex !== 'string') {
+            return hex;
+        }
+        if (!hex.startsWith('0x')) {
+            return hex;
+        }
+        if (hex.length <= length * 2) {
+            return hex;
+        }
+        return `${hex.slice(0, length)}...${hex.slice(-length)}`;
+    };
+    const formatRequestBody = (body)=>{
+        try {
+            const parsed = JSON.parse(body);
+            // Recursively process all parameters that might contain hex strings
+            const processParams = (obj)=>{
+                if (Array.isArray(obj)) {
+                    return obj.map((item)=>processParams(item));
+                }
+                if (typeof obj === 'object' && obj !== null) {
+                    const result = {};
+                    for (const [key, value] of Object.entries(obj)){
+                        result[key] = processParams(value);
+                    }
+                    return result;
+                }
+                if (typeof obj === 'string') {
+                    if (obj.startsWith('0x')) {
+                        return truncateHex(obj);
+                    }
+                }
+                return obj;
+            };
+            // Process the entire request body
+            const processed = processParams(parsed);
+            return JSON.stringify(processed, null, 2);
+        } catch  {
+            return body;
+        }
+    };
+    const truncateHexStringsInText = (text)=>{
+        const hexRegex = /\b0x[a-fA-F0-9]{10,}/g;
+        return text.replace(hexRegex, (hex)=>truncateHex(hex));
+    };
+    const extractAndFormatRequestBody = (message)=>{
+        // First handle Request body JSON
+        const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
+        let result = message.replace(requestBodyRegex, (match, body)=>{
+            return `Request body: ${formatRequestBody(body)}\n`;
+        });
+        // Then handle Arguments section
+        const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
+        result = result.replace(argsRegex, (section)=>{
+            const lines = section.split('\n');
+            const processedLines = lines.map((line)=>{
+                // Check if line contains a colon followed by content
+                const colonIndex = line.indexOf(':');
+                if (colonIndex !== -1) {
+                    const [prefix, content] = [
+                        line.slice(0, colonIndex + 1),
+                        line.slice(colonIndex + 1).trim()
+                    ];
+                    // If content contains a hex string, truncate it
+                    if (content.includes('0x')) {
+                        const hexMatches = content.match(/0x[a-fA-F0-9]+/g) || [];
+                        let processedContent = content;
+                        hexMatches.forEach((hex)=>{
+                            processedContent = processedContent.replace(hex, truncateHex(hex));
+                        });
+                        return `${prefix} ${processedContent}`;
+                    }
+                }
+                return line;
+            });
+            return processedLines.join('\n');
+        });
+        // Finally, catch any remaining hex strings in the message
+        result = truncateHexStringsInText(result);
+        return result;
+    };
+    const formattedRes = extractAndFormatRequestBody(error?.message || String(error));
+    return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+}
+export function tryGetCustomErrorName(err) {
+    try {
+        // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors
+        if (err.name === 'ViemError' || err.name === 'ContractFunctionExecutionError') {
+            const baseError = err;
+            const revertError = baseError.walk((err)=>err.name === 'ContractFunctionRevertedError');
+            if (revertError) {
+                return revertError.data?.errorName;
+            }
+        }
+    } catch (_e) {
+        return undefined;
+    }
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@aztec/ethereum",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./eth-cheatcodes": "./dest/eth_cheat_codes.js",
+    "./test": "./dest/test/index.js",
+    "./contracts": "./dest/contracts/index.js",
+    "./deploy-l1-contracts": "./dest/deploy_l1_contracts.js",
+    "./l1-contract-addresses": "./dest/l1_contract_addresses.js",
+    "./l1-tx-utils-with-blobs": "./dest/l1_tx_utils_with_blobs.js",
+    "./utils": "./dest/utils.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Ethereum",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "start:dev": "tsc-watch -p tsconfig.json --onSuccess 'yarn start'",
+    "start": "node ./dest/index.js",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "dependencies": {
+    "@aztec/blob-lib": "0.0.0-test.0",
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/l1-artifacts": "0.0.0-test.0",
+    "@viem/anvil": "^0.0.10",
+    "dotenv": "^16.0.3",
+    "tslib": "^2.4.0",
+    "viem": "2.22.8",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.14.6",
+    "@viem/anvil": "^0.0.10",
+    "get-port": "^7.1.0",
+    "jest": "^29.5.0",
+    "lodash.omit": "^4.5.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/chain.ts

@@ -0,0 +1,71 @@
+import type { Chain } from 'viem';
+import { foundry } from 'viem/chains';
+
+import { AZTEC_TEST_CHAIN_ID } from './constants.js';
+
+/**
+ * Interface containing the connection and chain properties to interact with a blockchain.
+ */
+export interface EthereumChain {
+  /**
+   * An instance of the viem chain data.
+   */
+  chainInfo: Chain;
+
+  /**
+   * The list of actual urls to be used.
+   */
+  rpcUrls: string[];
+}
+
+/**
+ * Helper function to create an instance of Aztec Chain from an rpc url and chain id.
+ * @param rpcUrls - The rpc url of the chain or a chain identifier (e.g. 'http://localhost:8545')
+ * @param chainId - The chain id of the chain or a chain identifier (e.g. 1337)
+ */
+export function createEthereumChain(rpcUrls: string[], _chainId: number | string): EthereumChain {
+  let chainId: number;
+  if (typeof _chainId === 'string') {
+    chainId = +_chainId;
+  } else {
+    chainId = _chainId;
+  }
+  if (chainId) {
+    return {
+      chainInfo: {
+        id: chainId,
+        name: 'Ethereum',
+        rpcUrls: {
+          default: {
+            http: rpcUrls,
+          },
+        },
+        nativeCurrency: {
+          decimals: 18,
+          name: 'Ether',
+          symbol: 'ETH',
+        },
+      },
+      rpcUrls,
+    };
+  } else {
+    return {
+      chainInfo: foundry,
+      rpcUrls,
+    };
+  }
+}
+
+/**
+ * Helper function to determine if a chain id is an instance of Anvil
+ */
+export function isAnvilTestChain(_chainId: number | string): boolean {
+  let chainId: number;
+  if (typeof _chainId === 'string') {
+    chainId = +_chainId;
+  } else {
+    chainId = _chainId;
+  }
+  const testChains = [foundry.id, AZTEC_TEST_CHAIN_ID];
+  return testChains.includes(chainId);
+}

package/src/client.ts

@@ -0,0 +1,58 @@
+import type { Logger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+
+import { createPublicClient, fallback, http } from 'viem';
+
+import { createEthereumChain } from './chain.js';
+import type { ViemPublicClient } from './types.js';
+
+type Config = {
+  /** The RPC Url of the ethereum host. */
+  l1RpcUrls: string[];
+  /** The chain ID of the ethereum host. */
+  l1ChainId: number;
+  /** The polling interval viem uses in ms */
+  viemPollingIntervalMS?: number;
+};
+
+// TODO: Use these methods to abstract the creation of viem clients.
+
+/** Returns a viem public client given the L1 config. */
+export function getPublicClient(config: Config): ViemPublicClient {
+  const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+  return createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(config.l1RpcUrls.map(url => http(url))),
+    pollingInterval: config.viemPollingIntervalMS,
+  });
+}
+
+/** Returns a viem public client after waiting for the L1 RPC node to become available. */
+export async function waitForPublicClient(config: Config, logger?: Logger): Promise<ViemPublicClient> {
+  const client = getPublicClient(config);
+  await waitForRpc(client, config, logger);
+  return client;
+}
+
+async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Logger) {
+  const l1ChainId = await retryUntil(
+    async () => {
+      let chainId = 0;
+      try {
+        chainId = await client.getChainId();
+      } catch (err) {
+        logger?.warn(`Failed to connect to Ethereum node at ${config.l1RpcUrls.join(', ')}. Retrying...`);
+      }
+      return chainId;
+    },
+    `L1 RPC url at ${config.l1RpcUrls.join(', ')}`,
+    600,
+    1,
+  );
+
+  if (l1ChainId !== config.l1ChainId) {
+    throw new Error(
+      `Ethereum node at ${config.l1RpcUrls.join(', ')} has chain ID ${l1ChainId} but expected ${config.l1ChainId}`,
+    );
+  }
+}

package/src/config.ts

@@ -0,0 +1,103 @@
+import {
+  type ConfigMappingsType,
+  bigintConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+
+import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './l1_tx_utils.js';
+
+export type L1ContractsConfig = {
+  /** How many seconds an L1 slot lasts. */
+  ethereumSlotDuration: number;
+  /** How many seconds an L2 slots lasts (must be multiple of ethereum slot duration). */
+  aztecSlotDuration: number;
+  /** How many L2 slots an epoch lasts. */
+  aztecEpochDuration: number;
+  /** The target validator committee size. */
+  aztecTargetCommitteeSize: number;
+  /** The number of L2 slots that we can wait for a proof of an epoch to be produced. */
+  aztecProofSubmissionWindow: number;
+  /** The minimum stake for a validator. */
+  minimumStake: bigint;
+  /** The slashing quorum */
+  slashingQuorum: number;
+  /** The slashing round size */
+  slashingRoundSize: number;
+  /** Governance proposing quorum */
+  governanceProposerQuorum: number;
+  /** Governance proposing round size */
+  governanceProposerRoundSize: number;
+} & L1TxUtilsConfig;
+
+export const DefaultL1ContractsConfig = {
+  ethereumSlotDuration: 12,
+  aztecSlotDuration: 24,
+  aztecEpochDuration: 16,
+  aztecTargetCommitteeSize: 48,
+  aztecProofSubmissionWindow: 31, // you have a full epoch to submit a proof after the epoch to prove ends
+  minimumStake: BigInt(100e18),
+  slashingQuorum: 6,
+  slashingRoundSize: 10,
+  governanceProposerQuorum: 6,
+  governanceProposerRoundSize: 10,
+} satisfies L1ContractsConfig;
+
+export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> = {
+  ethereumSlotDuration: {
+    env: 'ETHEREUM_SLOT_DURATION',
+    description: 'How many seconds an L1 slot lasts.',
+    ...numberConfigHelper(DefaultL1ContractsConfig.ethereumSlotDuration),
+  },
+  aztecSlotDuration: {
+    env: 'AZTEC_SLOT_DURATION',
+    description: 'How many seconds an L2 slots lasts (must be multiple of ethereum slot duration).',
+    ...numberConfigHelper(DefaultL1ContractsConfig.aztecSlotDuration),
+  },
+  aztecEpochDuration: {
+    env: 'AZTEC_EPOCH_DURATION',
+    description: `How many L2 slots an epoch lasts (maximum AZTEC_MAX_EPOCH_DURATION).`,
+    ...numberConfigHelper(DefaultL1ContractsConfig.aztecEpochDuration),
+  },
+  aztecTargetCommitteeSize: {
+    env: 'AZTEC_TARGET_COMMITTEE_SIZE',
+    description: 'The target validator committee size.',
+    ...numberConfigHelper(DefaultL1ContractsConfig.aztecTargetCommitteeSize),
+  },
+  aztecProofSubmissionWindow: {
+    env: 'AZTEC_PROOF_SUBMISSION_WINDOW',
+    description:
+      'The number of L2 slots that a proof for an epoch can be submitted in, starting from the beginning of the epoch.',
+    ...numberConfigHelper(DefaultL1ContractsConfig.aztecProofSubmissionWindow),
+  },
+  minimumStake: {
+    env: 'AZTEC_MINIMUM_STAKE',
+    description: 'The minimum stake for a validator.',
+    ...bigintConfigHelper(DefaultL1ContractsConfig.minimumStake),
+  },
+  slashingQuorum: {
+    env: 'AZTEC_SLASHING_QUORUM',
+    description: 'The slashing quorum',
+    ...numberConfigHelper(DefaultL1ContractsConfig.slashingQuorum),
+  },
+  slashingRoundSize: {
+    env: 'AZTEC_SLASHING_ROUND_SIZE',
+    description: 'The slashing round size',
+    ...numberConfigHelper(DefaultL1ContractsConfig.slashingRoundSize),
+  },
+  governanceProposerQuorum: {
+    env: 'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
+    description: 'The governance proposing quorum',
+    ...numberConfigHelper(DefaultL1ContractsConfig.governanceProposerQuorum),
+  },
+  governanceProposerRoundSize: {
+    env: 'AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE',
+    description: 'The governance proposing round size',
+    ...numberConfigHelper(DefaultL1ContractsConfig.governanceProposerRoundSize),
+  },
+  ...l1TxUtilsConfigMappings,
+};
+
+export function getL1ContractsConfigEnvVars(): L1ContractsConfig {
+  return getConfigFromMappings(l1ContractsConfigMappings);
+}

package/src/constants.ts

@@ -0,0 +1,4 @@
+import type { Hex } from 'viem';
+
+export const NULL_KEY: Hex = `0x${'0000000000000000000000000000000000000000000000000000000000000000'}`;
+export const AZTEC_TEST_CHAIN_ID = 677692;

package/src/contracts/empire_base.ts

@@ -0,0 +1,19 @@
+import { EmpireBaseAbi } from '@aztec/l1-artifacts/EmpireBaseAbi';
+
+import { type Hex, encodeFunctionData } from 'viem';
+
+import type { L1TxRequest } from '../l1_tx_utils.js';
+
+export interface IEmpireBase {
+  getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }>;
+  computeRound(slot: bigint): Promise<bigint>;
+  createVoteRequest(payload: Hex): L1TxRequest;
+}
+
+export function encodeVote(payload: Hex): Hex {
+  return encodeFunctionData({
+    abi: EmpireBaseAbi,
+    functionName: 'vote',
+    args: [payload],
+  });
+}

package/src/contracts/fee_juice.ts

@@ -0,0 +1,43 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
+
+import { type GetContractReturnType, type Hex, getContract } from 'viem';
+
+import type { L1Clients } from '../types.js';
+
+export class FeeJuiceContract {
+  private readonly publicFeeJuice: GetContractReturnType<typeof FeeJuiceAbi, L1Clients['publicClient']>;
+  private readonly walletFeeJuice: GetContractReturnType<typeof FeeJuiceAbi, L1Clients['walletClient']> | undefined;
+
+  constructor(
+    address: Hex,
+    public readonly publicClient: L1Clients['publicClient'],
+    public readonly walletClient: L1Clients['walletClient'] | undefined,
+  ) {
+    this.publicFeeJuice = getContract({ address, abi: FeeJuiceAbi, client: publicClient });
+    this.walletFeeJuice = walletClient ? getContract({ address, abi: FeeJuiceAbi, client: walletClient }) : undefined;
+  }
+
+  public get address() {
+    return EthAddress.fromString(this.publicFeeJuice.address);
+  }
+
+  private assertWalletFeeJuice() {
+    if (!this.walletFeeJuice) {
+      throw new Error('Wallet client is required for this operation');
+    }
+    return this.walletFeeJuice;
+  }
+
+  public async mint(to: Hex, amount: bigint) {
+    const walletFeeJuice = this.assertWalletFeeJuice();
+    const tx = await walletFeeJuice.write.mint([to, amount]);
+    await this.publicClient.waitForTransactionReceipt({ hash: tx });
+  }
+
+  public async approve(spender: Hex, amount: bigint) {
+    const walletFeeJuice = this.assertWalletFeeJuice();
+    const tx = await walletFeeJuice.write.approve([spender, amount]);
+    await this.publicClient.waitForTransactionReceipt({ hash: tx });
+  }
+}