@aztec/ethereum 3.0.0-nightly.20250911 → 3.0.0-nightly.20250913

package/src/test/chain_monitor.ts

@@ -10,7 +10,7 @@ import type { ViemClient } from '../types.js';
 
 export type ChainMonitorEventMap = {
   'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
-  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
+  'l2-block': [{ l2BlockNumber: number; l1BlockNumber: number; l2SlotNumber: number; timestamp: bigint }];
   'l2-block-proven': [{ l2ProvenBlockNumber: number; l1BlockNumber: number; timestamp: bigint }];
   'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
   'l2-epoch': [{ l2EpochNumber: number; timestamp: bigint; committee: EthAddress[] | undefined }];
@@ -102,8 +102,13 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
     }
     this.l1BlockNumber = newL1BlockNumber;
 
-    const block = await this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false });
-    const timestamp = block.timestamp;
+    const [l2SlotNumber, l2Epoch, l1block] = await Promise.all([
+      this.rollup.getSlotNumber(),
+      this.rollup.getCurrentEpoch(),
+      this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false }),
+    ]);
+
+    const timestamp = l1block.timestamp;
     const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
 
     this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
@@ -111,16 +116,21 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
 
     const newL2BlockNumber = Number(await this.rollup.getBlockNumber());
     if (this.l2BlockNumber !== newL2BlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2BlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2BlockNumber));
       msg += ` with new L2 block ${newL2BlockNumber} for epoch ${epochNumber}`;
       this.l2BlockNumber = newL2BlockNumber;
       this.l2BlockTimestamp = timestamp;
-      this.emit('l2-block', { l2BlockNumber: newL2BlockNumber, l1BlockNumber: newL1BlockNumber, timestamp });
+      this.emit('l2-block', {
+        l2BlockNumber: newL2BlockNumber,
+        l1BlockNumber: newL1BlockNumber,
+        l2SlotNumber: Number(l2SlotNumber),
+        timestamp,
+      });
     }
 
     const newL2ProvenBlockNumber = Number(await this.rollup.getProvenBlockNumber());
     if (this.l2ProvenBlockNumber !== newL2ProvenBlockNumber) {
-      const epochNumber = await this.rollup.getEpochNumber(BigInt(newL2ProvenBlockNumber));
+      const epochNumber = await this.rollup.getEpochNumberForBlock(BigInt(newL2ProvenBlockNumber));
       msg += ` with proof up to L2 block ${newL2ProvenBlockNumber} for epoch ${epochNumber}`;
       this.l2ProvenBlockNumber = newL2ProvenBlockNumber;
       this.l2ProvenBlockTimestamp = timestamp;
@@ -139,8 +149,6 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
     }
 
-    const [l2SlotNumber, l2Epoch] = await Promise.all([this.rollup.getSlotNumber(), this.rollup.getCurrentEpoch()]);
-
     let committee: EthAddress[] | undefined;
     if (l2Epoch !== this.l2EpochNumber) {
       this.l2EpochNumber = l2Epoch;
@@ -184,4 +192,52 @@ export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
       this.on('l2-slot', listener);
     });
   }
+
+  public waitUntilL1Block(block: number | bigint): Promise<void> {
+    const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
+    if (this.l1BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.l1BlockNumber >= targetBlock) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL1Timestamp(timestamp: number | bigint): Promise<void> {
+    const targetTimestamp = typeof timestamp === 'bigint' ? timestamp.valueOf() : timestamp;
+    if (this.l1BlockNumber >= targetTimestamp) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.timestamp >= targetTimestamp) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL2Block(l2BlockNumber: number | bigint): Promise<void> {
+    const targetBlock = typeof l2BlockNumber === 'bigint' ? l2BlockNumber.valueOf() : l2BlockNumber;
+    if (this.l2BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2BlockNumber: number; timestamp: bigint }) => {
+        if (data.l2BlockNumber >= targetBlock) {
+          this.off('l2-block', listener);
+          resolve();
+        }
+      };
+      this.on('l2-block', listener);
+    });
+  }
 }

package/src/utils.ts

@@ -181,41 +181,19 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     return new FormattedViemError(error.message, (error as any)?.metaMessages);
   }
 
-  // Extract the actual error message and highlight it for clarity
-  let formattedRes = extractAndFormatRequestBody(error?.message || String(error));
-
-  let errorDetail = '';
-  // Look for specific details in known locations
-  if (error) {
-    // Check for details property which often has the most specific error message
-    if (typeof error.details === 'string' && error.details) {
-      errorDetail = error.details;
-    }
-    // Check for shortMessage which is often available in Viem errors
-    else if (typeof error.shortMessage === 'string' && error.shortMessage) {
-      errorDetail = error.shortMessage;
-    }
-  }
-
-  // If we found a specific error detail, format it clearly
-  if (errorDetail) {
-    // Look for key sections of the formatted result to replace with highlighted error
-    let replaced = false;
-
-    // Try to find the Details: section
-    const detailsMatch = formattedRes.match(/Details: ([^\n]+)/);
-    if (detailsMatch) {
-      formattedRes = formattedRes.replace(detailsMatch[0], `Details: *${errorDetail}*`);
-      replaced = true;
-    }
-
-    // If we didn't find a Details section, add the error at the beginning
-    if (!replaced) {
-      formattedRes = `Error: *${errorDetail}*\n\n${formattedRes}`;
-    }
-  }
-
-  return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+  const body = String(error);
+  const length = body.length;
+  // LogExplorer can only render up to 2500 characters in it's summary view. Try to keep the whole message below this number
+  // Limit the error to 2000 chacaters in order to allow code higher up to decorate this error with extra details (up to 500 characters)
+  if (length > 2000) {
+    const chunk = 950;
+    const truncated = length - 2 * chunk;
+    return new FormattedViemError(
+      body.slice(0, chunk) + `...${truncated} characters truncated...` + body.slice(-1 * chunk),
+    );
+  }
+
+  return new FormattedViemError(body);
 }
 
 function stripAbis(obj: any) {
@@ -241,156 +219,6 @@ function stripAbis(obj: any) {
   });
 }
 
-function extractAndFormatRequestBody(message: string): string {
-  // First check if message is extremely large and contains very large hex strings
-  if (message.length > 50000) {
-    message = replaceHexStrings(message, { minLength: 10000, truncateLength: 200 });
-  }
-
-  // Add a specific check for RPC calls with large params
-  if (message.includes('"method":"eth_sendRawTransaction"')) {
-    message = replaceHexStrings(message, {
-      pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-      transform: hex => `"params":["${truncateHex(hex, 200)}"]`,
-    });
-  }
-
-  // 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 processedContent = replaceHexStrings(content);
-          return `${prefix} ${processedContent}`;
-        }
-      }
-      return line;
-    });
-    return processedLines.join('\n');
-  });
-
-  // Finally, catch any remaining hex strings in the message
-  result = replaceHexStrings(result);
-
-  return result;
-}
-
-function 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;
-  }
-  // For extremely large hex strings, use more aggressive truncation
-  if (hex.length > 10000) {
-    return `${hex.slice(0, length)}...<${hex.length - length * 2} chars omitted>...${hex.slice(-length)}`;
-  }
-  return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-}
-
-function replaceHexStrings(
-  text: string,
-  options: {
-    minLength?: number;
-    maxLength?: number;
-    truncateLength?: number;
-    pattern?: RegExp;
-    transform?: (hex: string) => string;
-  } = {},
-): string {
-  const {
-    minLength = 10,
-    maxLength = Infinity,
-    truncateLength = 100,
-    pattern,
-    transform = hex => truncateHex(hex, truncateLength),
-  } = options;
-
-  const hexRegex = pattern ?? new RegExp(`(0x[a-fA-F0-9]{${minLength},${maxLength}})`, 'g');
-  return text.replace(hexRegex, match => transform(match));
-}
-
-function formatRequestBody(body: string) {
-  try {
-    // Special handling for eth_sendRawTransaction
-    if (body.includes('"method":"eth_sendRawTransaction"')) {
-      try {
-        const parsed = JSON.parse(body);
-        if (parsed.params && Array.isArray(parsed.params) && parsed.params.length > 0) {
-          // These are likely large transaction hex strings
-          parsed.params = parsed.params.map((param: any) => {
-            if (typeof param === 'string' && param.startsWith('0x') && param.length > 1000) {
-              return truncateHex(param, 200);
-            }
-            return param;
-          });
-        }
-        return JSON.stringify(parsed, null, 2);
-      } catch {
-        // If specific parsing fails, fall back to regex-based truncation
-        return replaceHexStrings(body, {
-          pattern: /"params":\s*\[\s*"(0x[a-fA-F0-9]{1000,})"\s*\]/g,
-          transform: hex => `"params":["${truncateHex(hex, 200)}"]`,
-        });
-      }
-    }
-
-    // For extremely large request bodies, use simple truncation instead of parsing
-    if (body.length > 50000) {
-      const jsonStart = body.indexOf('{');
-      const jsonEnd = body.lastIndexOf('}');
-      if (jsonStart >= 0 && jsonEnd > jsonStart) {
-        return replaceHexStrings(body, { minLength: 10000, truncateLength: 200 });
-      }
-    }
-
-    const parsed = JSON.parse(body);
-
-    // Process the entire request body
-    const processed = processParams(parsed);
-    return JSON.stringify(processed, null, 2);
-  } catch {
-    // If JSON parsing fails, do a simple truncation of any large hex strings
-    return replaceHexStrings(body, { minLength: 1000, truncateLength: 150 });
-  }
-}
-
-// Recursively process all parameters that might contain hex strings
-function 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;
-}
-
 export function tryGetCustomErrorName(err: any) {
   try {
     // See https://viem.sh/docs/contract/simulateContract#handling-custom-errors