@aztec/ethereum 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/src/test/tx_delayer.ts

@@ -18,6 +18,8 @@ import {
 
 import { type ViemClient, isExtendedClient } from '../types.js';
 
+const MAX_WAIT_TIME_SECONDS = 180;
+
 export function waitUntilBlock<T extends Client>(
   client: T,
   blockNumber: number | bigint,
@@ -36,7 +38,7 @@ export function waitUntilBlock<T extends Client>(
       return currentBlockNumber >= BigInt(blockNumber);
     },
     `Wait until L1 block ${blockNumber}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
@@ -66,7 +68,7 @@ export function waitUntilL1Timestamp<T extends Client>(
       return currentTs >= BigInt(timestamp);
     },
     `Wait until L1 timestamp ${timestamp}`,
-    timeout ?? 120,
+    timeout ?? MAX_WAIT_TIME_SECONDS,
     0.1,
   );
 }
@@ -230,7 +232,7 @@ export function withDelayer<T extends ViemClient>(
           return Promise.resolve(txHash!);
         } else {
           const txHash = await client.sendRawTransaction(...args);
-          logger.verbose(`Sent tx immediately ${txHash}`);
+          logger.debug(`Sent tx immediately ${txHash}`);
           delayer.sentTxHashes.push(txHash);
           return txHash;
         }

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   Client,
   FallbackTransport,
   GetContractReturnType,
+  Hex,
   HttpTransport,
   PublicActions,
   PublicClient,
@@ -16,6 +17,67 @@ import type {
 /** Type for a viem public client */
 export type ViemPublicClient = PublicClient<FallbackTransport<HttpTransport[]>, Chain>;
 
+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[]>,
   Chain,

package/src/utils.ts

@@ -1,4 +1,4 @@
-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/ErrorsAbi';
 
@@ -8,6 +8,7 @@ import {
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
@@ -233,3 +234,31 @@ export function tryGetCustomErrorName(err: any) {
     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];
+}