@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/test/upgrade_utils.ts

@@ -1,36 +1,37 @@
 import type { Logger } from '@aztec/foundation/log';
-import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
+import { DateProvider } from '@aztec/foundation/timer';
 import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { TestERC20Abi as StakingAssetAbi } from '@aztec/l1-artifacts/TestERC20Abi';
 
 import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
 
-import { EthCheatCodes } from '../eth_cheat_codes.js';
+import { extractProposalIdFromLogs } from '../contracts/governance.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
-import type { L1Clients } from '../types.js';
+import { createL1TxUtils } from '../l1_tx_utils/index.js';
+import type { ExtendedViemWalletClient, ViemPublicClient } from '../types.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 
 export async function executeGovernanceProposal(
   proposalId: bigint,
-  governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>,
+  governance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>,
   voteAmount: bigint,
   privateKey: PrivateKeyAccount,
-  publicClient: L1Clients['publicClient'],
-  walletClient: L1Clients['walletClient'],
+  l1Client: ExtendedViemWalletClient,
   rpcUrls: string[],
   logger: Logger,
 ) {
   const proposal = await governance.read.getProposal([proposalId]);
 
+  const l1TxUtils = createL1TxUtils(l1Client);
+
   const waitL1Block = async () => {
-    await publicClient.waitForTransactionReceipt({
-      hash: await walletClient.sendTransaction({
-        to: privateKey.address,
-        value: 1n,
-        account: privateKey,
-      }),
+    await l1TxUtils.sendAndMonitorTransaction({
+      to: l1Client.account.address,
+      value: 1n,
     });
   };
 
-  const cheatCodes = new EthCheatCodes(rpcUrls, logger);
+  const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), logger);
 
   const timeToActive = proposal.creation + proposal.config.votingDelay;
   logger.info(`Warping to ${timeToActive + 1n}`);
@@ -40,7 +41,7 @@ export async function executeGovernanceProposal(
 
   logger.info(`Voting`);
   const voteTx = await governance.write.vote([proposalId, voteAmount, true], { account: privateKey });
-  await publicClient.waitForTransactionReceipt({ hash: voteTx });
+  await l1Client.waitForTransactionReceipt({ hash: voteTx });
   logger.info(`Voted`);
 
   const timeToExecutable = timeToActive + proposal.config.votingDuration + proposal.config.executionDelay + 1n;
@@ -50,7 +51,7 @@ export async function executeGovernanceProposal(
   await waitL1Block();
 
   const executeTx = await governance.write.execute([proposalId], { account: privateKey });
-  await publicClient.waitForTransactionReceipt({ hash: executeTx });
+  await l1Client.waitForTransactionReceipt({ hash: executeTx });
   logger.info(`Executed proposal`);
 }
 
@@ -58,12 +59,16 @@ export async function createGovernanceProposal(
   payloadAddress: `0x${string}`,
   addresses: L1ContractAddresses,
   privateKey: PrivateKeyAccount,
-  publicClient: L1Clients['publicClient'],
+  publicClient: ViemPublicClient,
   logger: Logger,
-): Promise<{ governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>; voteAmount: bigint }> {
+): Promise<{
+  governance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>;
+  voteAmount: bigint;
+  proposalId: bigint;
+}> {
   const token = getContract({
-    address: addresses.feeJuiceAddress.toString(),
-    abi: FeeJuiceAbi,
+    address: addresses.stakingAssetAddress.toString(),
+    abi: StakingAssetAbi,
     client: publicClient,
   });
 
@@ -92,9 +97,13 @@ export async function createGovernanceProposal(
   await publicClient.waitForTransactionReceipt({ hash: depositTx });
   logger.info(`Deposited tokens`);
 
-  await governance.write.proposeWithLock([payloadAddress, privateKey.address], {
+  const proposeTx = await governance.write.proposeWithLock([payloadAddress, privateKey.address], {
     account: privateKey,
   });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: proposeTx });
+  logger.info(`Proposed upgrade`);
+
+  const proposalId = extractProposalIdFromLogs(receipt.logs);
 
-  return { governance, voteAmount };
+  return { governance, voteAmount, proposalId };
 }

package/src/types.ts

@@ -1,21 +1,82 @@
 import type {
+  Abi,
   Account,
   Chain,
   Client,
   FallbackTransport,
+  GetContractReturnType,
+  Hex,
   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 PublicRpcDebugSchema = [
+  {
+    Method: 'debug_traceTransaction';
+    Parameters: [txHash: `0x${string}`, options: { tracer: 'callTracer' }];
+    ReturnType: DebugCallTrace;
+  },
+  {
+    Method: 'trace_transaction';
+    Parameters: [txHash: `0x${string}`];
+    ReturnType: TraceTransactionResponse[];
+  },
+];
+
+/** Return type for a debug_traceTransaction call */
+export type DebugCallTrace = {
+  from: Hex;
+  to?: Hex;
+  type: string;
+  input?: Hex;
+  output?: Hex;
+  gas?: Hex;
+  gasUsed?: Hex;
+  value?: Hex;
+  error?: string;
+  calls?: DebugCallTrace[];
+};
+
+/** Action object for a trace_transaction call */
+export type TraceAction = {
+  from: Hex;
+  to?: Hex;
+  callType: string;
+  gas?: Hex;
+  input?: Hex;
+  value?: Hex;
+};
+
+/** Result object for a trace_transaction call */
+export type TraceResult = {
+  gasUsed?: Hex;
+  output?: Hex;
+};
+
+/** Return type for a single trace in trace_transaction response */
+export type TraceTransactionResponse = {
+  action: TraceAction;
+  result?: TraceResult;
+  error?: string;
+  subtraces: number;
+  traceAddress: number[];
+  type: string;
+};
+
+/** Type for a viem public client with support for debug methods */
+export type ViemPublicDebugClient = PublicClient<
+  FallbackTransport<HttpTransport[]>,
+  Chain,
+  undefined,
+  [...PublicRpcSchema, ...PublicRpcDebugSchema]
+>;
 
 export type ExtendedViemWalletClient = Client<
   FallbackTransport<readonly HttpTransport[]>,
@@ -25,9 +86,12 @@ export type ExtendedViemWalletClient = Client<
   PublicActions<FallbackTransport<readonly HttpTransport[]>, Chain> & WalletActions<Chain, Account>
 >;
 
-export type ViemWalletClient = SimpleViemWalletClient | ExtendedViemWalletClient;
+/** Type for a viem client that can be either public or extended with wallet capabilities */
+export type ViemClient = ViemPublicClient | ExtendedViemWalletClient;
 
-export type L1Clients = {
-  publicClient: ViemPublicClient;
-  walletClient: ExtendedViemWalletClient;
-};
+/** Type for a viem contract that can be used with an extended viem client */
+export type ViemContract<TAbi extends Abi> = GetContractReturnType<TAbi, ExtendedViemWalletClient>;
+
+export function isExtendedClient(client: ViemClient): client is ExtendedViemWalletClient {
+  return 'account' in client && client.account !== undefined;
+}

package/src/utils.ts

@@ -1,18 +1,21 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
-import { ErrorsAbi } from '@aztec/l1-artifacts';
+import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,
+  type AbiItem,
   BaseError,
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
   decodeEventLog,
 } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
 
 export interface L2Claim {
   claimSecret: Fr;
@@ -24,8 +27,8 @@ export interface L2Claim {
 export class FormattedViemError extends Error {
   metaMessages?: any[];
 
-  constructor(message: string, metaMessages?: any[]) {
-    super(message);
+  constructor(message: string, metaMessages?: any[], options?: ErrorOptions) {
+    super(message, options);
     this.name = 'FormattedViemError';
     this.metaMessages = metaMessages;
   }
@@ -50,7 +53,7 @@ export function extractEvent<
   return event;
 }
 
-function tryExtractEvent<
+export function tryExtractEvent<
   const TAbi extends Abi | readonly unknown[],
   TEventName extends ContractEventName<TAbi>,
   TEventType = DecodeEventLogReturnType<TAbi, TEventName, Hex[], undefined, true>,
@@ -92,6 +95,57 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
+export function mergeAbis(abis: Abi[]): Abi {
+  let merged: Abi = [];
+  const seen = new Set<string>();
+
+  for (const abi of abis) {
+    for (const item of abi) {
+      const key = getAbiItemKey(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged = [...merged, item];
+      }
+    }
+  }
+
+  return merged;
+}
+
+function getAbiItemKey(item: AbiItem): string {
+  if (item.type === 'function') {
+    const signature = formatAbiItem(item);
+    const outputs = formatAbiParams(item.outputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `function:${signature}:${outputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'event') {
+    const signature = formatAbiItem(item);
+    const indexed = (item.inputs ?? []).map(input => ((input as { indexed?: boolean }).indexed ? '1' : '0')).join('');
+    const anonymous = item.anonymous ? 'anonymous' : 'not-anonymous';
+    return `event:${signature}:${indexed}:${anonymous}`;
+  }
+
+  if (item.type === 'error') {
+    const signature = formatAbiItem(item);
+    return `error:${signature}`;
+  }
+
+  if (item.type === 'constructor') {
+    const inputs = formatAbiParams(item.inputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `constructor::${inputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'fallback' || item.type === 'receive') {
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `${item.type}:::${stateMutability}`;
+  }
+
+  return 'unknown';
+}
+
 function getNestedErrorData(error: unknown): string | undefined {
   // If nothing, bail
   if (!error) {
@@ -116,6 +170,21 @@ function getNestedErrorData(error: unknown): string | undefined {
   return undefined;
 }
 
+/**
+ * Truncates an error message to a safe length for log renderers.
+ * LogExplorer can only render up to 2500 characters in its summary view.
+ * We cap at 2000 to leave room for decorating context added by callers.
+ */
+function truncateErrorMessage(message: string): string {
+  const MAX = 2000;
+  const CHUNK = 950;
+  if (message.length <= MAX) {
+    return message;
+  }
+  const truncated = message.length - 2 * CHUNK;
+  return message.slice(0, CHUNK) + `...${truncated} characters truncated...` + message.slice(-CHUNK);
+}
+
 /**
  * Formats a Viem error into a FormattedViemError instance.
  * @param error - The error to format.
@@ -128,6 +197,8 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     return error;
   }
 
+  const originalError = error;
+
   // First try to decode as a custom error using the ABI
   try {
     const data = getNestedErrorData(error);
@@ -138,7 +209,9 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
         data: data as Hex,
       });
       if (decoded) {
-        return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages);
+        return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages, {
+          cause: originalError,
+        });
       }
     }
 
@@ -155,109 +228,76 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
           revertError.metaMessages && revertError.metaMessages?.length > 1
             ? revertError.metaMessages[1].trimStart()
             : '';
-        return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
+        return new FormattedViemError(`${errorName}${args}`, error?.metaMessages, { cause: originalError });
       }
     }
-  } catch (decodeErr) {
+  } catch {
     // 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;
-  }
+  // Strip ABI from the error object before formatting
+  if (error && typeof error === 'object') {
+    // Create a clone to avoid modifying the original
+    const errorClone = structuredClone(error);
 
-  // Original formatting logic for non-custom errors
-  const truncateHex = (hex: string, 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)}`;
-  };
+    // Helper function to recursively remove ABI properties
 
-  const formatRequestBody = (body: string) => {
-    try {
-      const parsed = JSON.parse(body);
+    // Strip ABIs from the clone
+    stripAbis(errorClone);
 
-      // Recursively process all parameters that might contain hex strings
-      const processParams = (obj: any): any => {
-        if (Array.isArray(obj)) {
-          return obj.map(item => processParams(item));
-        }
-        if (typeof obj === 'object' && obj !== null) {
-          const result: any = {};
-          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: string): string => {
-    const hexRegex = /\b0x[a-fA-F0-9]{10,}/g;
-    return text.replace(hexRegex, hex => truncateHex(hex));
-  };
-
-  const extractAndFormatRequestBody = (message: string): string => {
-    // 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`;
-    });
+    // Use the cleaned clone for further processing
+    error = errorClone;
+  }
 
-    // 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');
+  // If it's a regular Error instance, return it with its message
+  if (error instanceof Error) {
+    return new FormattedViemError(truncateErrorMessage(error.message), (error as any)?.metaMessages, {
+      cause: originalError,
     });
+  }
 
-    // Finally, catch any remaining hex strings in the message
-    result = truncateHexStringsInText(result);
+  return new FormattedViemError(truncateErrorMessage(String(error)), undefined, { cause: originalError });
+}
 
-    return result;
-  };
+function stripAbis(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return;
+  }
 
-  const formattedRes = extractAndFormatRequestBody(error?.message || String(error));
+  // Delete ABI property at current level
+  if ('abi' in obj) {
+    delete obj.abi;
+  }
 
-  return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+  // Process cause property
+  if (obj.cause) {
+    stripAbis(obj.cause);
+  }
+
+  // Process arrays and objects
+  Object.values(obj).forEach(value => {
+    if (value && typeof value === 'object') {
+      stripAbis(value);
+    }
+  });
+}
+
+/**
+ * Best-effort decode of a raw revert payload (`0x...`) against an ABI.
+ * Returns a human-readable `ErrorName(arg1, arg2, ...)` string, or `undefined` if the selector
+ * is unknown or the payload is empty. Use to surface decoded error names alongside the raw
+ * payload in log lines for operators.
+ */
+export function tryDecodeRevertReason(data: Hex | undefined, abi: Abi): string | undefined {
+  if (!data || data === '0x') {
+    return undefined;
+  }
+  try {
+    const decoded = decodeErrorResult({ abi, data });
+    return `${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`;
+  } catch {
+    return undefined;
+  }
 }
 
 export function tryGetCustomErrorName(err: any) {
@@ -270,7 +310,35 @@ export function tryGetCustomErrorName(err: any) {
         return (revertError as ContractFunctionRevertedError).data?.errorName;
       }
     }
-  } catch (_e) {
+  } catch {
     return undefined;
   }
 }
+
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */
+export function isBlobTransaction(tx: FormattedTransaction): tx is FormattedTransaction & {
+  maxFeePerBlobGas: bigint;
+  blobVersionedHashes: readonly Hex[];
+} {
+  return (
+    'maxFeePerBlobGas' in tx &&
+    tx.maxFeePerBlobGas !== undefined &&
+    'blobVersionedHashes' in tx &&
+    tx.blobVersionedHashes !== undefined
+  );
+}
+
+/**
+ * Calculates a percentile from an array of bigints
+ */
+export function calculatePercentile(values: bigint[], percentile: number): bigint {
+  if (values.length === 0) {
+    return 0n;
+  }
+  const sorted = [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+  return sorted[index];
+}

package/src/zkPassportVerifierAddress.ts

@@ -0,0 +1,15 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+/**
+ * The address of the zk passport verifier on sepolia
+ * get address from: ROOT/l1-contracts/lib/circuits/src/solidity/deployments/deployment-11155111.json
+ */
+export const ZK_PASSPORT_VERIFIER_ADDRESS = EthAddress.fromString('0x3101Bad9eA5fACadA5554844a1a88F7Fe48D4DE0');
+/**
+ * The default domain of the zk passport site
+ */
+export const ZK_PASSPORT_DOMAIN = 'testnet.aztec.network';
+/**
+ * The default scope of the zk passport proofs
+ */
+export const ZK_PASSPORT_SCOPE = 'personhood';

package/dest/contracts/forwarder.d.ts

@@ -1,24 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import { type Hex } from 'viem';
-import type { L1BlobInputs, L1GasConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
-import type { L1Clients, ViemPublicClient, ViemWalletClient } from '../types.js';
-export declare class ForwarderContract {
-    readonly client: L1Clients['publicClient'];
-    readonly rollupAddress: Hex;
-    private readonly forwarder;
-    constructor(client: L1Clients['publicClient'], address: Hex, rollupAddress: Hex);
-    static create(owner: Hex, walletClient: ViemWalletClient, publicClient: ViemPublicClient, logger: Logger, rollupAddress: Hex): Promise<ForwarderContract>;
-    getAddress(): `0x${string}`;
-    forward(requests: L1TxRequest[], l1TxUtils: L1TxUtils, gasConfig: L1GasConfig | undefined, blobConfig: L1BlobInputs | undefined, logger: Logger): Promise<{
-        receipt: import("viem").TransactionReceipt;
-        gasPrice: import("../l1_tx_utils.js").GasPrice;
-        stats: import("../l1_tx_utils.js").TransactionStats | undefined;
-        errorMsg?: undefined;
-    } | {
-        receipt: import("viem").TransactionReceipt;
-        gasPrice: import("../l1_tx_utils.js").GasPrice;
-        errorMsg: string | undefined;
-        stats?: undefined;
-    }>;
-}
-//# sourceMappingURL=forwarder.d.ts.map

package/dest/contracts/forwarder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"forwarder.d.ts","sourceRoot":"","sources":["../../src/contracts/forwarder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAGL,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGjF,qBAAa,iBAAiB;aAGA,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC;aAAgC,aAAa,EAAE,GAAG;IAF/G,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+D;gBAE7D,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,EAAkB,aAAa,EAAE,GAAG;WAIlG,MAAM,CACjB,KAAK,EAAE,GAAG,EACV,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,GAAG;IAwBb,UAAU;IAIJ,OAAO,CAClB,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,WAAW,GAAG,SAAS,EAClC,UAAU,EAAE,YAAY,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM;;;;;;;;;;;CAqEjB"}