@aztec/foundation 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/eth-signature/eth_signature.ts

@@ -5,27 +5,30 @@ import { z } from 'zod';
 
 import { hasHexPrefix, hexToBuffer } from '../string/index.js';
 
-/**Viem Signature
- *
- * A version of the Signature class that uses `0x${string}` values for r and s rather than
- * Buffer32s
+/**
+ * A version of the Signature class that uses `0x${string}` values for r and s rather than Buffer32s
  */
 export type ViemSignature = {
   r: `0x${string}`;
   s: `0x${string}`;
   v: number;
-  isEmpty: boolean;
+};
+
+export type ViemTransactionSignature = {
+  r: `0x${string}`;
+  s: `0x${string}`;
+  yParity: 0 | 1;
 };
 
 /**
- * Signature
- *
  * Contains a signature split into it's primary components (r,s,v)
  */
 export class Signature {
   // Cached values
   private size: number | undefined;
 
+  public readonly empty: boolean;
+
   constructor(
     /** The r value of the signature */
     public readonly r: Buffer32,
@@ -33,9 +36,9 @@ export class Signature {
     public readonly s: Buffer32,
     /** The v value of the signature */
     public readonly v: number,
-    /** Does this struct store an empty signature */
-    public readonly isEmpty: boolean = false,
-  ) {}
+  ) {
+    this.empty = r.isZero() && s.isZero() && v === 0;
+  }
 
   static fromBuffer(buf: Buffer | BufferReader): Signature {
     const reader = BufferReader.asReader(buf);
@@ -44,9 +47,7 @@ export class Signature {
     const s = reader.readObject(Buffer32);
     const v = reader.readNumber();
 
-    const isEmpty = r.isZero() && s.isZero();
-
-    return new Signature(r, s, v, isEmpty);
+    return new Signature(r, s, v);
   }
 
   static isValidString(sig: `0x${string}`): boolean {
@@ -65,27 +66,35 @@ export class Signature {
     const s = reader.readObject(Buffer32);
     const v = parseInt(sig.slice(2 + 64 * 2), 16);
 
-    const isEmpty = r.isZero() && s.isZero();
+    return new Signature(r, s, v);
+  }
+
+  static fromViemSignature(sig: ViemSignature): Signature {
+    return new Signature(Buffer32.fromBuffer(hexToBuffer(sig.r)), Buffer32.fromBuffer(hexToBuffer(sig.s)), sig.v);
+  }
 
-    return new Signature(r, s, v, isEmpty);
+  static fromViemTransactionSignature(sig: ViemTransactionSignature): Signature {
+    return new Signature(Buffer32.fromBuffer(hexToBuffer(sig.r)), Buffer32.fromBuffer(hexToBuffer(sig.s)), sig.yParity);
   }
 
   static random(): Signature {
-    return new Signature(Buffer32.random(), Buffer32.random(), Math.floor(Math.random() * 2), false);
+    return new Signature(Buffer32.random(), Buffer32.random(), 1);
   }
 
   static empty(): Signature {
-    return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0, true);
+    return new Signature(Buffer32.ZERO, Buffer32.ZERO, 0);
+  }
+
+  isEmpty(): boolean {
+    return this.empty;
   }
 
   equals(other: Signature): boolean {
-    return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.isEmpty === other.isEmpty;
+    return this.r.equals(other.r) && this.s.equals(other.s) && this.v === other.v && this.empty === other.empty;
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.r, this.s, this.v]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.r, this.s, this.v]);
   }
 
   getSize(): number {
@@ -110,7 +119,20 @@ export class Signature {
       r: this.r.toString(),
       s: this.s.toString(),
       v: this.v,
-      isEmpty: this.isEmpty,
+    };
+  }
+
+  /**
+   * Return the signature with `0x${string}` encodings for r and s. Verifies v is valid
+   */
+  toViemTransactionSignature(): ViemTransactionSignature {
+    if (this.v !== 0 && this.v !== 1) {
+      throw new Error('Invalid transaction signature');
+    }
+    return {
+      r: this.r.toString(),
+      s: this.s.toString(),
+      yParity: this.v,
     };
   }
 

package/src/fs/index.ts

@@ -1 +1,2 @@
 export * from './run_in_dir.js';
+export * from './try_rm_dir.js';

package/src/fs/try_rm_dir.ts

@@ -0,0 +1,15 @@
+import { rm } from 'fs/promises';
+
+import type { Logger } from '../log/index.js';
+
+export async function tryRmDir(dir: string | undefined, logger?: Logger): Promise<void> {
+  if (dir === undefined) {
+    return;
+  }
+  try {
+    logger?.debug(`Cleaning up directory at ${dir}`);
+    await rm(dir, { recursive: true, force: true, maxRetries: 3 });
+  } catch (err) {
+    logger?.warn(`Failed to delete directory at ${dir}: ${err}`);
+  }
+}

package/src/iterable/filter.ts

@@ -51,7 +51,7 @@ function filter<T>(
         yield value;
       }
 
-      for await (const entry of peekable) {
+      for (const entry of peekable) {
         if (await fn(entry, index++)) {
           yield entry;
         }

package/src/iterable/map.ts

@@ -46,7 +46,7 @@ function map<I, O>(
     return (async function* () {
       yield await res;
 
-      for await (const val of peekable) {
+      for (const val of peekable) {
         yield func(val, index++);
       }
     })();

package/src/iterator/filter.ts

@@ -0,0 +1,11 @@
+/** Wraps an async iterable iterator such that it filters values based on a predicate. */
+export async function* filter<T>(
+  iterator: AsyncIterableIterator<T>,
+  predicate: (item: T) => boolean | Promise<boolean>,
+): AsyncIterableIterator<T> {
+  for await (const item of iterator) {
+    if (await predicate(item)) {
+      yield item;
+    }
+  }
+}

package/src/iterator/index.ts

@@ -0,0 +1 @@
+export { filter } from './filter.js';

package/src/jest/env.mjs

@@ -0,0 +1,52 @@
+import { TestEnvironment } from 'jest-environment-node';
+
+// What errors should be ignored in after hooks
+const IgnoredErrors = ['HttpRequestError', 'CodeError'];
+
+/** Custom Jest environment that ignores any whitelisted unhandled rejections that occur during `after` hooks */
+export default class CustomEnvironment extends TestEnvironment {
+  constructor(config, context) {
+    super(config, context);
+  }
+
+  async handleTestEvent(event, state) {
+    if (event.name === 'setup') {
+      // Jest 29 reports both unhandledRejection and uncaughtException events as plain `error`, without any means to differentiate them
+      // (see https://github.com/jestjs/jest/issues/9210). Jest 30 fixes it as part of a larger change (see
+      // https://github.com/jestjs/jest/pull/14315/files#diff-9bdc1fdb60c8631b1e346eff6e4899c4e64ae3a44f4f12d0d7ac70c2aabd1d93R12-R29),
+      // but we cannot update to 30 as it is still in beta at the time of writing this code. So we remove jest's unhandledRejection listener,
+      // replace it with our own, and delegate to the original listener only if the error is not in the ignored list.
+      const parentProcess = event.parentProcess;
+      const [jestListener] = parentProcess.listeners('unhandledRejection');
+      parentProcess.removeAllListeners('unhandledRejection');
+      const patchedListener = (err, _promise) => {
+        if (state.isInAfterHook && IgnoredErrors.some(error => err && err.name && err.name.includes(error))) {
+          // Ignore the error only if it was an unhandled async rejection (not sync exception), it's on the IgnoredErrors list, and we're in an after hook.
+          console.error('Ignoring unhandled rejection in after hook:', err);
+        } else if (state.isInAfterHook) {
+          // Log non-ignored unhandled rejection in an after hook, and pass the error to the original jest listener to fail the test.
+          console.error(`Unhandled rejection in after hook:`, err);
+          jestListener && jestListener(err);
+        } else {
+          // Otherwise, just delegate to the original jest listener, to emit the `error` event under the hood.
+          jestListener && jestListener(err);
+        }
+      };
+      parentProcess.on('unhandledRejection', patchedListener);
+      state.patchedListener = patchedListener;
+    } else if (event.name === 'teardown') {
+      // Remove the patched handler we added in setup.
+      const parentProcess = state.parentProcess;
+      parentProcess.removeListener('unhandledRejection', state.patchedListener);
+    } else if (event.name === 'hook_start' && event.hook.type.startsWith('after')) {
+      // Track that we have entered an after hook.
+      state.isInAfterHook = true;
+    } else if (
+      (event.name === 'hook_success' || event.name === 'hook_failure') &&
+      event.hook.type.startsWith('after')
+    ) {
+      // Reset the flag that we are in an after hook when we exit it.
+      state.isInAfterHook = false;
+    }
+  }
+}

package/src/jest/setup.mjs

@@ -1,3 +1,4 @@
+import { parseBooleanEnv } from '@aztec/foundation/config';
 import { overwriteLoggingStream, pinoPrettyOpts } from '@aztec/foundation/log';
 
 import pretty from 'pino-pretty';
@@ -6,4 +7,6 @@ import pretty from 'pino-pretty';
 // 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));
+if (!parseBooleanEnv(process.env.LOG_JSON)) {
+  overwriteLoggingStream(pretty(pinoPrettyOpts));
+}

package/src/jest/setupAfterEnv.mjs

@@ -0,0 +1,3 @@
+if (Array.isArray(globalThis.__extraEqualityTesters)) {
+  expect.addEqualityTesters(globalThis.__extraEqualityTesters);
+}

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

@@ -8,9 +8,7 @@ const log = createLogger('json-rpc:json_rpc_client');
 
 export type JsonRpcFetch = (
   host: string,
-  rpcMethod: string,
   body: any,
-  useApiEndpoints: boolean,
   extraHeaders?: Record<string, string>,
   noRetry?: boolean,
 ) => Promise<{ response: any; headers: { get: (header: string) => string | null | undefined } }>;
@@ -27,45 +25,35 @@ export type JsonRpcFetch = (
  */
 export async function defaultFetch(
   host: string,
-  rpcMethod: string,
-  body: any,
-  useApiEndpoints: boolean,
+  body: unknown,
   extraHeaders: Record<string, string> = {},
   noRetry = false,
 ): Promise<{ response: any; headers: { get: (header: string) => string | null | undefined } }> {
-  log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
+  log.debug(format(`JsonRpcClient.fetch`, host, '->', body));
   let resp: Response;
   try {
-    if (useApiEndpoints) {
-      resp = await fetch(`${host}/${rpcMethod}`, {
-        method: 'POST',
-        body: jsonStringify(body),
-        headers: { 'content-type': 'application/json', ...extraHeaders },
-      });
-    } else {
-      resp = await fetch(host, {
-        method: 'POST',
-        body: jsonStringify({ ...body, method: rpcMethod }),
-        headers: { 'content-type': 'application/json', ...extraHeaders },
-      });
-    }
+    resp = await fetch(host, {
+      method: 'POST',
+      body: jsonStringify(body),
+      headers: { 'content-type': 'application/json', ...extraHeaders },
+    });
   } catch (err) {
-    const errorMessage = `Error fetching from host ${host} with method ${rpcMethod}: ${inspect(err)}`;
+    const errorMessage = `Error fetching from host ${host}: ${inspect(err)}`;
     throw new Error(errorMessage);
   }
 
   let responseJson;
   try {
     responseJson = await resp.json();
-  } catch (err) {
+  } catch {
     if (!resp.ok) {
       throw new Error(resp.statusText);
     }
-    throw new Error(`Failed to parse body as JSON: ${resp.text()}`);
+    throw new Error(`Failed to parse body as JSON: ${await resp.text()}`);
   }
 
   if (!resp.ok) {
-    const errorMessage = `Error ${resp.status} from server ${host} on ${rpcMethod}: ${responseJson.error.message}`;
+    const errorMessage = `Error ${resp.status} from server ${host}: ${responseJson.error.message}`;
     if (noRetry || (resp.status >= 400 && resp.status < 500)) {
       throw new NoRetryError(errorMessage);
     } else {
@@ -84,17 +72,10 @@ export async function defaultFetch(
  * @returns A fetch function.
  */
 export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger): typeof defaultFetch {
-  return async (
-    host: string,
-    rpcMethod: string,
-    body: any,
-    useApiEndpoints: boolean,
-    extraHeaders: Record<string, string> = {},
-    noRetry?: boolean,
-  ) => {
+  return async (host: string, body: unknown, extraHeaders: Record<string, string> = {}, noRetry?: boolean) => {
     return await retry(
-      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, extraHeaders, noRetry ?? defaultNoRetry),
-      `JsonRpcClient request ${rpcMethod} to ${host}`,
+      () => defaultFetch(host, body, extraHeaders, noRetry ?? defaultNoRetry),
+      `JsonRpcClient request to ${host}`,
       makeBackoff(retries),
       log,
       false,

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

@@ -1,27 +1,67 @@
 import { format } from 'util';
 
 import { type Logger, createLogger } from '../../log/pino-logger.js';
+import { type PromiseWithResolvers, promiseWithResolvers } from '../../promise/utils.js';
 import { type ApiSchema, type ApiSchemaFor, schemaHasMethod } from '../../schemas/api.js';
+import { jsonStringify } from '../convert.js';
 import { type JsonRpcFetch, defaultFetch } from './fetch.js';
 
+// batch window of 0 would capture all requests in the current sync iteration of the event loop
+// and send them all at once in a single batch
+// minimal latency
+const DEFAULT_BATCH_WINDOW_MS = 0;
+
+// the maximum size of a batched request
+const DEFAULT_MAX_BATCH_SIZE = 100;
+
+// 10 mb
+const DEFAULT_MAX_REQUESTY_BODY_SIZE = 10 * 1024 * 1024;
+
 export type SafeJsonRpcClientOptions = {
-  useApiEndpoints?: boolean;
   namespaceMethods?: string | false;
   fetch?: JsonRpcFetch;
   log?: Logger;
+  batchWindowMS?: number;
+  maxBatchSize?: number;
+  maxRequestBodySize?: number;
   onResponse?: (res: {
     response: any;
     headers: { get: (header: string) => string | null | undefined };
   }) => Promise<void>;
 };
 
+type JsonRpcRequest = {
+  jsonrpc: '2.0';
+  id?: number;
+  method: string;
+  params?: Array<any>;
+};
+
+type JsonRpcResponse =
+  | {
+      jsonrpc: '2.0';
+      id?: number;
+      result: any;
+    }
+  | {
+      jsonrpc: '2.0';
+      id?: number;
+      error: { code: number; data?: any; message: string };
+    };
+
+// expose helpful information on the RPC clients such that we can recognize them later
+const SEND_BATCH = Symbol('JsonRpcClient.sendBatch');
+const CLIENT_ID = Symbol('JsonRpcClient.clientId');
+
+let nextClientId = 1;
+// keep a reference to clients so that we can force send a batch
+const clients = new Map<number, WeakRef<{ [SEND_BATCH]: () => Promise<void> }>>();
+
 /**
  * Creates a Proxy object that delegates over RPC and validates outputs against a given schema.
  * The server is expected to be a JsonRpcServer.
  * @param host - The host URL.
  * @param schema - The api schema to validate returned data against.
- * @param useApiEndpoints - Whether to use the API endpoints or the default RPC endpoint.
- * @param namespaceMethods - String value (or false/empty) to namespace all methods sent to the server. e.g. 'getInfo' -\> 'pxe_getInfo'
  * @param fetch - The fetch implementation to use.
  */
 export function createSafeJsonRpcClient<T extends object>(
@@ -31,25 +71,164 @@ export function createSafeJsonRpcClient<T extends object>(
 ): T {
   const fetch = config.fetch ?? defaultFetch;
   const log = config.log ?? createLogger('json-rpc:client');
-  const { useApiEndpoints = false, namespaceMethods = false } = config;
+  const {
+    namespaceMethods = false,
+    batchWindowMS = DEFAULT_BATCH_WINDOW_MS,
+    maxBatchSize = DEFAULT_MAX_BATCH_SIZE,
+    maxRequestBodySize = DEFAULT_MAX_REQUESTY_BODY_SIZE,
+  } = config;
 
   let id = 0;
+  let sendBatchTimeoutHandle: NodeJS.Timeout | undefined;
+  const queue: Array<{
+    request: JsonRpcRequest;
+    deferred: PromiseWithResolvers<JsonRpcResponse>;
+    encodedLength: number;
+  }> = [];
+
+  const sendBatch = async (): Promise<void> => {
+    if (sendBatchTimeoutHandle !== undefined) {
+      clearTimeout(sendBatchTimeoutHandle);
+      sendBatchTimeoutHandle = undefined;
+    }
+
+    const rpcCalls: typeof queue = [];
+    let bodySize = 0;
+
+    while (queue.length > 0 && rpcCalls.length < maxBatchSize && bodySize < maxRequestBodySize) {
+      const item = queue[0];
+      if (!item) {
+        break;
+      }
+
+      const tmpBodySize = bodySize + item.encodedLength;
+      if (tmpBodySize >= maxRequestBodySize) {
+        break;
+      }
+
+      bodySize = tmpBodySize;
+      queue.shift();
+      rpcCalls.push(item);
+    }
+
+    // no-op
+    if (rpcCalls.length === 0) {
+      return;
+    }
+
+    // schedule another call if there are more items to send
+    if (queue.length > 0) {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      sendBatchTimeoutHandle = setTimeout(sendBatch, batchWindowMS);
+    }
+
+    log.debug(`Executing JSON-RPC batch of size: ${rpcCalls.length} body size: ${bodySize} bytes`, {
+      methods: rpcCalls.map(({ request }) => request.method),
+    });
+    try {
+      const { response, headers } = await fetch(
+        host,
+        rpcCalls.map(({ request }) => request),
+      );
+
+      if (config.onResponse) {
+        await config.onResponse({ response, headers });
+      }
+
+      if (!Array.isArray(response) || response.length !== rpcCalls.length) {
+        log.warn(
+          `Invalid response received from JSON-RPC server. Expected array of responses of length ${rpcCalls.length}`,
+          { response },
+        );
+        for (let i = 0; i < rpcCalls.length; i++) {
+          const { request, deferred } = rpcCalls[i];
+          deferred.resolve({
+            id: request.id,
+            jsonrpc: '2.0',
+            error: {
+              code: -32000,
+              data: response,
+              message: response.message ?? 'Failed request',
+            },
+          });
+        }
+      } else {
+        for (let i = 0; i < response.length; i++) {
+          const resp: JsonRpcResponse = response[i];
+          const { request, deferred } = rpcCalls[i];
+
+          if (resp.id !== request.id) {
+            log.warn(`Invalid response received at index ${i} from JSON-RPC server: id mismatch`, {
+              requestMethod: request.method,
+              requestId: request.id,
+              responseId: resp.id,
+            });
+            deferred.resolve({
+              id: request.id,
+              jsonrpc: '2.0',
+              error: {
+                code: -32001,
+                data: resp,
+                message: 'RPC id mismatch',
+              },
+            });
+          } else {
+            deferred.resolve(resp);
+          }
+        }
+      }
+    } catch (err) {
+      // Re-throw ComponentsVersionsError immediately without converting to JSON-RPC error
+      // This ensures version mismatch errors are surfaced to the user instead of being hidden
+      if (err && typeof err === 'object' && 'name' in err && err.name === 'ComponentsVersionsError') {
+        // Reject all pending requests with the version error
+        for (let i = 0; i < rpcCalls.length; i++) {
+          rpcCalls[i].deferred.reject(err);
+        }
+        return; // Return early, the promises are already rejected
+      }
+      log.warn(`Failed to fetch from the remote server`, err);
+      for (let i = 0; i < rpcCalls.length; i++) {
+        const { request, deferred } = rpcCalls[i];
+        deferred.resolve({
+          id: request.id,
+          jsonrpc: '2.0',
+          error: {
+            code: -32000,
+            data: err,
+            message: (err as any).message ?? 'Failed request',
+          },
+        });
+      }
+    }
+  };
+
   const request = async (methodName: string, params: any[]): Promise<any> => {
     if (!schemaHasMethod(schema, methodName)) {
       throw new Error(`Unspecified method ${methodName} in client schema`);
     }
     const method = namespaceMethods ? `${namespaceMethods}_${methodName}` : methodName;
-    const body = { jsonrpc: '2.0', id: id++, method, params };
+    const body: JsonRpcRequest = { jsonrpc: '2.0', id: id++, method, params };
+
+    const deferred = promiseWithResolvers<JsonRpcResponse>();
+    const encodedLength = jsonStringify(body).length;
+    if (encodedLength >= maxRequestBodySize) {
+      throw new Error(`Request body too large: ${encodedLength}`);
+    }
+
+    queue.push({ request: body, deferred, encodedLength });
+
+    if (sendBatchTimeoutHandle === undefined) {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      sendBatchTimeoutHandle = setTimeout(sendBatch, batchWindowMS);
+    }
 
     log.debug(format(`request`, method, params));
-    const { response, headers } = await fetch(host, method, body, useApiEndpoints);
+    const response = await deferred.promise;
     log.debug(format(`result`, method, response));
 
-    if (config.onResponse) {
-      await config.onResponse({ response, headers });
-    }
-    if (response.error) {
-      throw response.error;
+    if ('error' in response) {
+      throw new Error(response.error.message, { cause: response.error });
     }
     // TODO(palla/schemas): Find a better way to handle null responses (JSON.stringify(null) is string "null").
     if ([null, undefined, 'null', 'undefined'].includes(response.result)) {
@@ -58,10 +237,44 @@ export function createSafeJsonRpcClient<T extends object>(
     return (schema as ApiSchema)[methodName].returnType().parseAsync(response.result);
   };
 
-  const proxy: any = {};
+  const clientId = nextClientId++;
+  const proxy: any = { [CLIENT_ID]: clientId, [SEND_BATCH]: sendBatch };
   for (const method of Object.keys(schema)) {
-    proxy[method] = (...params: any[]) => request(method, params);
+    // attach the clientId to the promise so that if we want to trigger a batch immediately, we can do that
+    proxy[method] = (...params: any[]) => Object.assign(request(method, params), { [CLIENT_ID]: clientId });
   }
 
+  clients.set(clientId, new WeakRef(proxy));
+
   return proxy as T;
 }
+
+/**
+ * Triggers a batch to be sent immediately
+ */
+export async function batch<T extends readonly unknown[]>(
+  values: T,
+): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }> {
+  const clientIdsSeen = new Set<number>();
+
+  await Promise.allSettled(
+    values.map(val => {
+      if (typeof val === 'object' && val && Object.hasOwn(val, CLIENT_ID)) {
+        const clientId = (val as { [CLIENT_ID]: any })[CLIENT_ID];
+        if (typeof clientId === 'number') {
+          if (clientIdsSeen.has(clientId)) {
+            return;
+          }
+
+          clientIdsSeen.add(clientId);
+          const client = clients.get(clientId)?.deref();
+          if (client) {
+            return client[SEND_BATCH]();
+          }
+        }
+      }
+    }),
+  );
+
+  return Promise.all(values);
+}