@aztec/foundation 0.66.0 → 0.67.1-devnet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/foundation",
-  "version": "0.66.0",
+  "version": "0.67.1-devnet",
   "packageManager": "yarn@3.4.1",
   "type": "module",
   "main": "./dest/index.js",
@@ -41,12 +41,14 @@
     "./wasm": "./dest/wasm/index.js",
     "./worker": "./dest/worker/index.js",
     "./bigint-buffer": "./dest/bigint-buffer/index.js",
+    "./blob": "./dest/blob/index.js",
     "./types": "./dest/types/index.js",
     "./schemas": "./dest/schemas/index.js",
     "./url": "./dest/url/index.js",
     "./committable": "./dest/committable/index.js",
     "./noir": "./dest/noir/index.js",
     "./testing": "./dest/testing/index.js",
+    "./testing/files": "./dest/testing/files/index.js",
     "./array": "./dest/array/index.js",
     "./validation": "./dest/validation/index.js",
     "./promise": "./dest/promise/index.js",
@@ -96,13 +98,21 @@
           "summaryThreshold": 9999
         }
       ]
+    ],
+    "testTimeout": 30000,
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.66.0",
+    "@aztec/bb.js": "0.67.1-devnet",
     "@koa/cors": "^5.0.0",
     "@noble/curves": "^1.2.0",
     "bn.js": "^5.2.1",
+    "c-kzg": "4.0.0-alpha.1",
     "colorette": "^2.0.20",
     "debug": "^4.3.4",
     "detect-node": "^2.1.0",
@@ -133,7 +143,6 @@
     "@types/koa": "^2.13.5",
     "@types/koa-bodyparser": "^4.3.10",
     "@types/koa-compress": "^4.0.3",
-    "@types/koa-cors": "^0.0.2",
     "@types/koa-router": "^7.4.4",
     "@types/koa__cors": "^4.0.0",
     "@types/leveldown": "^4.0.3",

package/src/abi/abi.ts

@@ -3,6 +3,7 @@ import { inflate } from 'pako';
 import { z } from 'zod';
 
 import { type Fr } from '../fields/fields.js';
+import { createLogger } from '../log/index.js';
 import { schemas } from '../schemas/schemas.js';
 import { type ZodFor } from '../schemas/types.js';
 import { type FunctionSelector } from './function_selector.js';
@@ -15,6 +16,8 @@ export interface BasicValue<T extends string, V> {
   value: V;
 }
 
+const logger = createLogger('aztec:foundation:abi');
+
 /** An exported value. */
 export type AbiValue =
   | BasicValue<'boolean', boolean>
@@ -390,7 +393,9 @@ export function getFunctionArtifact(
   if (!functionArtifact) {
     throw new Error(`Unknown function ${functionNameOrSelector}`);
   }
+
   const debugMetadata = getFunctionDebugMetadata(artifact, functionArtifact);
+
   return { ...functionArtifact, debug: debugMetadata };
 }
 
@@ -404,18 +409,32 @@ export function getFunctionDebugMetadata(
   contractArtifact: ContractArtifact,
   functionArtifact: FunctionArtifact,
 ): FunctionDebugMetadata | undefined {
-  if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
-    const programDebugSymbols = JSON.parse(
-      inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), { to: 'string', raw: true }),
-    );
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
-    // We only support handling debug info for the contract function entry point.
-    // So for now we simply index into the first debug info.
-    return {
-      debugSymbols: programDebugSymbols.debug_infos[0],
-      files: contractArtifact.fileMap,
-    };
+  try {
+    if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10546) investigate why debugMetadata is so big for some tests.
+      const programDebugSymbols = JSON.parse(
+        inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), { to: 'string', raw: true }),
+      );
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
+      // We only support handling debug info for the contract function entry point.
+      // So for now we simply index into the first debug info.
+      return {
+        debugSymbols: programDebugSymbols.debug_infos[0],
+        files: contractArtifact.fileMap,
+      };
+    }
+  } catch (err: any) {
+    if (err instanceof RangeError && err.message.includes('Invalid string length')) {
+      logger.warn(
+        `Caught RangeError: Invalid string length. This suggests the debug_symbols field of the contract ${contractArtifact.name} and function ${functionArtifact.name} is huge; too big to parse. We'll skip returning this info until this issue is resolved. Here's the error:\n${err.message}`,
+      );
+      // We'll return undefined.
+    } else {
+      // Rethrow unexpected errors
+      throw err;
+    }
   }
+
   return undefined;
 }
 

package/src/abi/encoder.ts

@@ -49,7 +49,7 @@ class ArgumentEncoder {
         } else if (typeof arg === 'bigint') {
           this.flattened.push(new Fr(arg));
         } else if (typeof arg === 'string') {
-          this.flattened.push(Fr.fromString(arg));
+          this.flattened.push(Fr.fromHexString(arg));
         } else if (typeof arg === 'boolean') {
           this.flattened.push(new Fr(arg ? 1n : 0n));
         } else if (typeof arg === 'object') {
@@ -58,7 +58,7 @@ class ArgumentEncoder {
           } else if (typeof arg.toField === 'function') {
             this.flattened.push(arg.toField());
           } else if (typeof arg.value === 'string') {
-            this.flattened.push(Fr.fromString(arg.value));
+            this.flattened.push(Fr.fromHexString(arg.value));
           } else {
             throw new Error(`Argument for ${name} cannot be serialized to a field`);
           }

package/src/abi/event_selector.ts

@@ -62,7 +62,7 @@ export class EventSelector extends Selector {
   static fromString(selector: string) {
     const buf = fromHex(selector);
     if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid Selector length ${buf.length} (expected ${Selector.SIZE}).`);
+      throw new Error(`Invalid EventSelector length ${buf.length} (expected ${Selector.SIZE}).`);
     }
     return EventSelector.fromBuffer(buf);
   }

package/src/abi/function_selector.ts

@@ -91,7 +91,7 @@ export class FunctionSelector extends Selector {
   static fromString(selector: string) {
     const buf = fromHex(selector);
     if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid Selector length ${buf.length} (expected ${Selector.SIZE}).`);
+      throw new Error(`Invalid FunctionSelector length ${buf.length} (expected ${Selector.SIZE}).`);
     }
     return FunctionSelector.fromBuffer(buf);
   }

package/src/blob/index.ts

@@ -0,0 +1,152 @@
+import cKzg from 'c-kzg';
+import type { Blob as BlobBuffer } from 'c-kzg';
+
+import { poseidon2Hash, sha256 } from '../crypto/index.js';
+import { Fr } from '../fields/index.js';
+import { serializeToBuffer } from '../serialize/index.js';
+
+// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
+/* eslint-disable import/no-named-as-default-member */
+
+const {
+  BYTES_PER_BLOB,
+  FIELD_ELEMENTS_PER_BLOB,
+  blobToKzgCommitment,
+  computeKzgProof,
+  loadTrustedSetup,
+  verifyKzgProof,
+} = cKzg;
+
+try {
+  loadTrustedSetup();
+} catch (error: any) {
+  if (error.message.includes('trusted setup is already loaded')) {
+    // NB: The c-kzg lib has no way of checking whether the setup is loaded or not,
+    // and it throws an error if it's already loaded, even though nothing is wrong.
+    // This is a rudimentary way of ensuring we load the trusted setup if we need it.
+  } else {
+    throw new Error(error);
+  }
+}
+
+// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
+export const VERSIONED_HASH_VERSION_KZG = 0x01;
+
+/**
+ * A class to create, manage, and prove EVM blobs.
+ */
+export class Blob {
+  /** The blob to be broadcast on L1 in bytes form. */
+  public readonly data: BlobBuffer;
+  /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
+  public readonly fieldsHash: Fr;
+  /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
+  public readonly challengeZ: Fr;
+  /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
+  public readonly evaluationY: Buffer;
+  /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+  public readonly commitment: Buffer;
+  /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
+  public readonly proof: Buffer;
+
+  constructor(
+    /** All fields to be broadcast in the blob. */
+    fields: Fr[],
+    /** If we want to broadcast more fields than fit into a blob, we hash those and used it as the fieldsHash across all blobs.
+     * This is much simpler and cheaper in the circuit to do, but MUST BE CHECKED before injecting here.
+     */
+    multiBlobFieldsHash?: Fr,
+  ) {
+    if (fields.length > FIELD_ELEMENTS_PER_BLOB) {
+      throw new Error(
+        `Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELD_ELEMENTS_PER_BLOB}`,
+      );
+    }
+    this.data = Buffer.concat([serializeToBuffer(fields)], BYTES_PER_BLOB);
+    // This matches the output of SpongeBlob.squeeze() in the blob circuit
+    this.fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : poseidon2Hash(fields);
+    this.commitment = Buffer.from(blobToKzgCommitment(this.data));
+    this.challengeZ = poseidon2Hash([this.fieldsHash, ...this.commitmentToFields()]);
+    const res = computeKzgProof(this.data, this.challengeZ.toBuffer());
+    if (!verifyKzgProof(this.commitment, this.challengeZ.toBuffer(), res[1], res[0])) {
+      throw new Error(`KZG proof did not verify.`);
+    }
+    this.proof = Buffer.from(res[0]);
+    this.evaluationY = Buffer.from(res[1]);
+  }
+
+  // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
+  commitmentToFields(): [Fr, Fr] {
+    return [new Fr(this.commitment.subarray(0, 31)), new Fr(this.commitment.subarray(31, 48))];
+  }
+
+  // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+  getEthVersionedBlobHash(): Buffer {
+    const hash = sha256(this.commitment);
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+  }
+
+  static getEthVersionedBlobHash(commitment: Buffer): Buffer {
+    const hash = sha256(commitment);
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+  }
+
+  // Returns a proof of opening of the blob to verify on L1 using the point evaluation precompile:
+  //  * input[:32]     - versioned_hash
+  //  * input[32:64]   - z
+  //  * input[64:96]   - y
+  //  * input[96:144]  - commitment C
+  //  * input[144:192] - proof (a commitment to the quotient polynomial q(X))
+  // See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+  getEthBlobEvaluationInputs(): `0x${string}` {
+    const buf = Buffer.concat([
+      this.getEthVersionedBlobHash(),
+      this.challengeZ.toBuffer(),
+      this.evaluationY,
+      this.commitment,
+      this.proof,
+    ]);
+    return `0x${buf.toString('hex')}`;
+  }
+
+  static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}` {
+    let buf = Buffer.alloc(0);
+    blobs.forEach(blob => {
+      buf = Buffer.concat([
+        buf,
+        blob.getEthVersionedBlobHash(),
+        blob.challengeZ.toBuffer(),
+        blob.evaluationY,
+        blob.commitment,
+        blob.proof,
+      ]);
+    });
+    // For multiple blobs, we prefix the number of blobs:
+    const lenBuf = Buffer.alloc(1);
+    lenBuf.writeUint8(blobs.length);
+    buf = Buffer.concat([lenBuf, buf]);
+    return `0x${buf.toString('hex')}`;
+  }
+
+  static getViemKzgInstance() {
+    return {
+      blobToKzgCommitment: cKzg.blobToKzgCommitment,
+      computeBlobKzgProof: cKzg.computeBlobKzgProof,
+    };
+  }
+
+  // Returns as many blobs as we require to broadcast the given fields
+  // Assumes we share the fields hash between all blobs
+  static getBlobs(fields: Fr[]): Blob[] {
+    const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
+    const multiBlobFieldsHash = poseidon2Hash(fields);
+    const res = [];
+    for (let i = 0; i < numBlobs; i++) {
+      const end = fields.length < (i + 1) * FIELD_ELEMENTS_PER_BLOB ? fields.length : (i + 1) * FIELD_ELEMENTS_PER_BLOB;
+      res.push(new Blob(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
+    }
+    return res;
+  }
+}

package/src/collection/array.ts

@@ -145,3 +145,13 @@ export function areArraysEqual<T>(a: T[], b: T[], eq: (a: T, b: T) => boolean =
 export function maxBy<T>(arr: T[], fn: (x: T) => number): T | undefined {
   return arr.reduce((max, x) => (fn(x) > fn(max) ? x : max), arr[0]);
 }
+
+/** Computes the median of a numeric array. Returns undefined if array is empty. */
+export function median(arr: number[]) {
+  if (arr.length === 0) {
+    return undefined;
+  }
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}

package/src/collection/object.ts

@@ -28,3 +28,25 @@ export function compact<T extends object>(obj: T): { [P in keyof T]+?: Exclude<T
   }
   return result;
 }
+
+/** Returns a new object by picking the given keys. */
+export function pick<T extends object, U extends keyof T>(object: T, ...props: U[]): Pick<T, U>;
+export function pick<T extends object>(object: T, ...props: string[]): Partial<T>;
+export function pick<T extends object>(object: T, ...props: string[]): Partial<T> {
+  const obj: any = {};
+  for (const prop of props) {
+    obj[prop] = (object as any)[prop];
+  }
+  return obj;
+}
+
+/** Returns a new object by omitting the given keys. */
+export function omit<T extends object, K extends keyof T>(object: T, ...props: K[]): Omit<T, K>;
+export function omit<T extends object>(object: T, ...props: string[]): Partial<T>;
+export function omit<T extends object>(object: T, ...props: string[]): Partial<T> {
+  const obj: any = { ...object };
+  for (const prop of props) {
+    delete obj[prop];
+  }
+  return obj;
+}

package/src/config/env_var.ts

@@ -52,14 +52,17 @@ export type EnvVar =
   | 'GOVERNANCE_PROPOSER_PAYLOAD_ADDRESS'
   | 'INBOX_CONTRACT_ADDRESS'
   | 'L1_CHAIN_ID'
+  | 'L1_CONSENSUS_CLIENT_URL'
   | 'L1_PRIVATE_KEY'
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
   | 'LOG_JSON'
+  | 'LOG_MULTILINE'
   | 'LOG_LEVEL'
   | 'MNEMONIC'
   | 'NETWORK_NAME'
   | 'NETWORK'
+  | 'NO_PXE'
   | 'COIN_ISSUER_CONTRACT_ADDRESS'
   | 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
   | 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'
@@ -123,8 +126,6 @@ export type EnvVar =
   | 'PROVER_REAL_PROOFS'
   | 'PROVER_REQUIRED_CONFIRMATIONS'
   | 'PROVER_TEST_DELAY_MS'
-  | 'PROVER_CACHE_DIR'
-  | 'PXE_BLOCK_POLLING_INTERVAL_MS'
   | 'PXE_L2_STARTING_BLOCK'
   | 'PXE_PROVER_ENABLED'
   | 'QUOTE_PROVIDER_BASIS_POINT_FEE'
@@ -135,11 +136,8 @@ export type EnvVar =
   | 'REGISTRY_CONTRACT_ADDRESS'
   | 'ROLLUP_CONTRACT_ADDRESS'
   | 'SEQ_ALLOWED_SETUP_FN'
-  | 'SEQ_ALLOWED_TEARDOWN_FN'
   | 'SEQ_MAX_BLOCK_SIZE_IN_BYTES'
-  | 'SEQ_MAX_SECONDS_BETWEEN_BLOCKS'
   | 'SEQ_MAX_TX_PER_BLOCK'
-  | 'SEQ_MIN_SECONDS_BETWEEN_BLOCKS'
   | 'SEQ_MIN_TX_PER_BLOCK'
   | 'SEQ_PUBLISH_RETRY_INTERVAL_MS'
   | 'SEQ_PUBLISHER_PRIVATE_KEY'
@@ -182,4 +180,11 @@ export type EnvVar =
   | 'L1_TX_MONITOR_MAX_ATTEMPTS'
   | 'L1_TX_MONITOR_CHECK_INTERVAL_MS'
   | 'L1_TX_MONITOR_STALL_TIME_MS'
-  | 'L1_TX_MONITOR_TX_TIMEOUT_MS';
+  | 'L1_TX_MONITOR_TX_TIMEOUT_MS'
+  | 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS'
+  | 'FAUCET_MNEMONIC_ACCOUNT_INDEX'
+  | 'FAUCET_ETH_AMOUNT'
+  | 'FAUCET_INTERVAL_MS'
+  | 'FAUCET_L1_ASSETS'
+  | 'K8S_POD_NAME'
+  | 'K8S_POD_UID';

package/src/crypto/random/randomness_singleton.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../../log/pino-logger.js';
+import { createLogger } from '../../log/pino-logger.js';
 
 /**
  * A number generator which is used as a source of randomness in the system. If the SEED env variable is set, the
@@ -15,7 +15,7 @@ export class RandomnessSingleton {
 
   private constructor(
     private readonly seed?: number,
-    private readonly log = createDebugLogger('aztec:randomness_singleton'),
+    private readonly log = createLogger('foundation:randomness_singleton'),
   ) {
     if (seed !== undefined) {
       this.log.debug(`Using pseudo-randomness with seed: ${seed}`);

package/src/fields/fields.ts

@@ -232,12 +232,31 @@ export class Fr extends BaseField {
     return fromBufferReduce(buffer, Fr);
   }
 
+  /**
+   * Creates a Fr instance from a string.
+   * @param buf - the string to create a Fr from.
+   * @returns the Fr instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */
+  static fromString(buf: string) {
+    if (buf.match(/^\d+$/) !== null) {
+      return new Fr(toBufferBE(BigInt(buf), 32));
+    }
+    if (buf.match(/^0x/i) !== null) {
+      return fromHexString(buf, Fr);
+    }
+
+    throw new Error('Tried to create a Fr from an invalid string');
+  }
+
   /**
    * Creates a Fr instance from a hex string.
    * @param buf - a hex encoded string.
    * @returns the Fr instance
    */
-  static fromString(buf: string) {
+  static fromHexString(buf: string) {
     return fromHexString(buf, Fr);
   }
 
@@ -368,12 +387,31 @@ export class Fq extends BaseField {
     return fromBufferReduce(buffer, Fq);
   }
 
+  /**
+   * Creates a Fq instance from a string.
+   * @param buf - the string to create a Fq from.
+   * @returns the Fq instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */
+  static fromString(buf: string) {
+    if (buf.match(/^\d+$/) !== null) {
+      return new Fq(toBufferBE(BigInt(buf), 32));
+    }
+    if (buf.match(/^0x/i) !== null) {
+      return fromHexString(buf, Fq);
+    }
+
+    throw new Error('Tried to create a Fq from an invalid string');
+  }
+
   /**
    * Creates a Fq instance from a hex string.
    * @param buf - a hex encoded string.
    * @returns the Fq instance
    */
-  static fromString(buf: string) {
+  static fromHexString(buf: string) {
     return fromHexString(buf, Fq);
   }
 

package/src/fs/run_in_dir.ts

@@ -1,4 +1,4 @@
-import * as fs from 'fs/promises';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 
 // Create a random directory underneath a 'base' directory

package/src/index.ts

@@ -3,6 +3,7 @@ export * as abi from './abi/index.js';
 export * as asyncMap from './async-map/index.js';
 export * as aztecAddress from './aztec-address/index.js';
 export * as bigintBuffer from './bigint-buffer/index.js';
+export * as blob from './blob/index.js';
 export * as collection from './collection/index.js';
 export * as committable from './committable/index.js';
 export * as crypto from './crypto/index.js';

package/src/iterable/index.ts

@@ -4,3 +4,4 @@ export * from './sort.js';
 export * from './take.js';
 export * from './all.js';
 export * from './peek.js';
+export * from './toArray.js';

package/src/iterable/toArray.ts

@@ -0,0 +1,7 @@
+export async function toArray<T>(iterator: AsyncIterableIterator<T> | IterableIterator<T>): Promise<T[]> {
+  const arr = [];
+  for await (const i of iterator) {
+    arr.push(i);
+  }
+  return arr;
+}

package/src/jest/setup.mjs

@@ -0,0 +1,9 @@
+import { overwriteLoggingStream, pinoPrettyOpts } from '@aztec/foundation/log';
+
+import pretty from 'pino-pretty';
+
+// Overwrite logging stream with pino-pretty. We define this as a separate
+// file so we don't mess up with dependencies in non-testing environments,
+// since pino-pretty messes up with browser bundles.
+// See also https://www.npmjs.com/package/pino-pretty?activeTab=readme#user-content-usage-with-jest
+overwriteLoggingStream(pretty(pinoPrettyOpts));

package/src/json-rpc/client/fetch.ts

@@ -1,10 +1,10 @@
 import { format, inspect } from 'util';
 
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
+import { type Logger, createLogger } from '../../log/index.js';
 import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
 import { jsonStringify } from '../convert.js';
 
-const log = createDebugLogger('json-rpc:json_rpc_client');
+const log = createLogger('json-rpc:json_rpc_client');
 
 /**
  * A normal fetch function that does not retry.
@@ -73,7 +73,7 @@ export async function defaultFetch(
  * @param log - Optional logger for logging attempts.
  * @returns A fetch function.
  */
-export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: DebugLogger) {
+export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger) {
   return async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, noRetry?: boolean) => {
     return await retry(
       () => defaultFetch(host, rpcMethod, body, useApiEndpoints, noRetry ?? defaultNoRetry),

package/src/json-rpc/client/safe_json_rpc_client.ts

@@ -1,6 +1,6 @@
 import { format } from 'util';
 
-import { createDebugLogger } from '../../log/pino-logger.js';
+import { createLogger } from '../../log/pino-logger.js';
 import { type ApiSchema, type ApiSchemaFor, schemaHasMethod } from '../../schemas/api.js';
 import { defaultFetch } from './fetch.js';
 
@@ -19,7 +19,7 @@ export function createSafeJsonRpcClient<T extends object>(
   useApiEndpoints: boolean = false,
   namespaceMethods?: string | false,
   fetch = defaultFetch,
-  log = createDebugLogger('json-rpc:client'),
+  log = createLogger('json-rpc:client'),
 ): T {
   let id = 0;
   const request = async (methodName: string, params: any[]): Promise<any> => {
@@ -44,18 +44,10 @@ export function createSafeJsonRpcClient<T extends object>(
     return (schema as ApiSchema)[methodName].returnType().parse(res.result);
   };
 
-  // Intercept any RPC methods with a proxy
-  const proxy = new Proxy(
-    {},
-    {
-      get: (target, method: string) => {
-        if (['then', 'catch'].includes(method)) {
-          return Reflect.get(target, method);
-        }
-        return (...params: any[]) => request(method, params);
-      },
-    },
-  ) as T;
+  const proxy: any = {};
+  for (const method of Object.keys(schema)) {
+    proxy[method] = (...params: any[]) => request(method, params);
+  }
 
-  return proxy;
+  return proxy as T;
 }

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -8,7 +8,7 @@ import { type AddressInfo } from 'net';
 import { format, inspect } from 'util';
 import { ZodError } from 'zod';
 
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
+import { type Logger, createLogger } from '../../log/index.js';
 import { promiseWithResolvers } from '../../promise/utils.js';
 import { type ApiSchema, type ApiSchemaFor, parseWithOptionals, schemaHasMethod } from '../../schemas/index.js';
 import { jsonStringify } from '../convert.js';
@@ -27,7 +27,7 @@ export class SafeJsonRpcServer {
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
     /** Logger */
-    private log = createDebugLogger('json-rpc:server'),
+    private log = createLogger('json-rpc:server'),
   ) {}
 
   public isHealthy(): boolean | Promise<boolean> {
@@ -170,7 +170,7 @@ interface Proxy {
  * before forwarding calls, and then converts outputs into JSON using default conversions.
  */
 export class SafeJsonProxy<T extends object = any> implements Proxy {
-  private log = createDebugLogger('json-rpc:proxy');
+  private log = createLogger('json-rpc:proxy');
   private schema: ApiSchema;
 
   constructor(private handler: T, schema: ApiSchemaFor<T>) {
@@ -233,7 +233,7 @@ export function makeHandler<T extends object>(handler: T, schema: ApiSchemaFor<T
   return [handler, schema];
 }
 
-function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: DebugLogger): StatusCheckFn {
+function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Logger): StatusCheckFn {
   return async () => {
     try {
       const results = await Promise.all(
@@ -259,7 +259,7 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: De
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
-  log = createDebugLogger('json-rpc:server'),
+  log = createLogger('json-rpc:server'),
 ): SafeJsonRpcServer {
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);

package/src/log/log-filters.ts

@@ -42,7 +42,13 @@ export function parseFilters(definition: string | undefined): LogFilters {
     const sanitizedLevel = level.trim().toLowerCase();
     assertLogLevel(sanitizedLevel);
     for (const module of modules.split(',')) {
-      filters.push([module.trim().toLowerCase(), sanitizedLevel as LogLevel | 'silent']);
+      filters.push([
+        module
+          .trim()
+          .toLowerCase()
+          .replace(/^aztec:/, ''),
+        sanitizedLevel as LogLevel | 'silent',
+      ]);
     }
   }
   return filters.reverse();

package/src/log/log_fn.ts

@@ -2,4 +2,4 @@
 export type LogData = Record<string, string | number | bigint | boolean | { toString(): string } | undefined>;
 
 /** A callable logger instance. */
-export type LogFn = (msg: string, data?: LogData) => void;
+export type LogFn = (msg: string, data?: unknown) => void;