@aztec/ethereum 0.69.0-devnet → 0.69.1-devnet

package/src/test/tx_delayer.ts

@@ -27,7 +27,7 @@ export function waitUntilBlock<T extends Client>(client: T, blockNumber: number
       return currentBlockNumber >= BigInt(blockNumber);
     },
     `Wait until L1 block ${blockNumber}`,
-    60,
+    120,
     0.1,
   );
 }
@@ -52,7 +52,7 @@ export function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: num
       return currentTs >= BigInt(timestamp);
     },
     `Wait until L1 timestamp ${timestamp}`,
-    60,
+    120,
     0.1,
   );
 }
@@ -144,7 +144,7 @@ export function withDelayer<T extends WalletClient>(
           return Promise.resolve(txHash);
         } else {
           const txHash = await client.sendRawTransaction(...args);
-          logger.debug(`Sent tx immediately ${txHash}`);
+          logger.verbose(`Sent tx immediately ${txHash}`);
           delayer.txs.push(txHash);
           return txHash;
         }

package/src/utils.ts

@@ -3,7 +3,9 @@ import { type Logger } from '@aztec/foundation/log';
 
 import {
   type Abi,
+  BaseError,
   type ContractEventName,
+  ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
   type Hex,
   type Log,
@@ -64,3 +66,110 @@ function tryExtractEvent<
     }
   }
 }
+
+export function prettyLogViemErrorMsg(err: any) {
+  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;
+}
+
+export function formatViemError(error: any): string {
+  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)}`;
+  };
+
+  const formatRequestBody = (body: string) => {
+    try {
+      const parsed = JSON.parse(body);
+
+      // 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`;
+    });
+
+    // 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;
+  };
+
+  return JSON.stringify({ error: extractAndFormatRequestBody(error?.message || String(error)) }, null, 2).replace(
+    /\\n/g,
+    '\n',
+  );
+}