@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/iterable/take.js

@@ -0,0 +1,32 @@
+import { isAsyncIterable } from './isAsyncIt.js';
+function take(source, limit) {
+    if (isAsyncIterable(source)) {
+        return async function*() {
+            let items = 0;
+            if (limit < 1) {
+                return;
+            }
+            for await (const entry of source){
+                yield entry;
+                items++;
+                if (items === limit) {
+                    return;
+                }
+            }
+        }();
+    }
+    return function*() {
+        let items = 0;
+        if (limit < 1) {
+            return;
+        }
+        for (const entry of source){
+            yield entry;
+            items++;
+            if (items === limit) {
+                return;
+            }
+        }
+    }();
+}
+export { take };

package/dest/iterable/toArray.d.ts

@@ -0,0 +1,2 @@
+export declare function toArray<T>(iterator: Iterable<T> | AsyncIterableIterator<T> | AsyncIterable<T> | IterableIterator<T>): Promise<T[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9BcnJheS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2l0ZXJhYmxlL3RvQXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXNCLE9BQU8sQ0FBQyxDQUFDLEVBQzdCLFFBQVEsRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDLEdBQUcscUJBQXFCLENBQUMsQ0FBQyxDQUFDLEdBQUcsYUFBYSxDQUFDLENBQUMsQ0FBQyxHQUFHLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxHQUN4RixPQUFPLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FNZCJ9

package/dest/iterable/toArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../src/iterable/toArray.ts"],"names":[],"mappings":"AAAA,wBAAsB,OAAO,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,EAAE,CAAC,CAMd"}

package/dest/iterable/toArray.js

@@ -0,0 +1,7 @@
+export async function toArray(iterator) {
+    const arr = [];
+    for await (const i of iterator){
+        arr.push(i);
+    }
+    return arr;
+}

package/dest/iterator/filter.d.ts

@@ -0,0 +1,3 @@
+/** Wraps an async iterable iterator such that it filters values based on a predicate. */
+export declare function filter<T>(iterator: AsyncIterableIterator<T>, predicate: (item: T) => boolean | Promise<boolean>): AsyncIterableIterator<T>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaXRlcmF0b3IvZmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlGQUF5RjtBQUN6Rix3QkFBdUIsTUFBTSxDQUFDLENBQUMsRUFDN0IsUUFBUSxFQUFFLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxFQUNsQyxTQUFTLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLE9BQU8sR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQ2pELHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQU0xQiJ9

package/dest/iterator/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/iterator/filter.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,wBAAuB,MAAM,CAAC,CAAC,EAC7B,QAAQ,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAClC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjD,qBAAqB,CAAC,CAAC,CAAC,CAM1B"}

package/dest/iterator/filter.js

@@ -0,0 +1,7 @@
+/** Wraps an async iterable iterator such that it filters values based on a predicate. */ export async function* filter(iterator, predicate) {
+    for await (const item of iterator){
+        if (await predicate(item)) {
+            yield item;
+        }
+    }
+}

package/dest/iterator/index.d.ts

@@ -0,0 +1,2 @@
+export { filter } from './filter.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pdGVyYXRvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sYUFBYSxDQUFDIn0=

package/dest/iterator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/iterator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dest/iterator/index.js

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

package/dest/jest/env.js

@@ -0,0 +1,48 @@
+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/dest/jest/setup.js

@@ -0,0 +1,34 @@
+import { parseBooleanEnv } from '@aztec-labs/foundation/config';
+import { overwriteLoggingStream, pinoPrettyOpts } from '@aztec-labs/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
+if (!parseBooleanEnv(process.env.LOG_JSON)) {
+    overwriteLoggingStream(pretty(pinoPrettyOpts));
+}
+// Prevent timers from keeping the process alive after tests complete.
+// Libraries like viem create internal polling loops (via setTimeout) that
+// reschedule themselves indefinitely. In test environments we never want a
+// timer to be the reason the process can't exit. We also unref stdout/stderr
+// which, when they are pipes (as in Jest workers), remain ref'd by default.
+{
+    const origSetTimeout = globalThis.setTimeout;
+    const origSetInterval = globalThis.setInterval;
+    globalThis.setTimeout = function unrefSetTimeout(...args) {
+        const id = origSetTimeout.apply(this, args);
+        id?.unref?.();
+        return id;
+    };
+    // Preserve .unref, .__promisify__ etc. that may exist on the original
+    Object.setPrototypeOf(globalThis.setTimeout, origSetTimeout);
+    globalThis.setInterval = function unrefSetInterval(...args) {
+        const id = origSetInterval.apply(this, args);
+        id?.unref?.();
+        return id;
+    };
+    Object.setPrototypeOf(globalThis.setInterval, origSetInterval);
+    if (process.stdout?._handle?.unref) process.stdout._handle.unref();
+    if (process.stderr?._handle?.unref) process.stderr._handle.unref();
+}

package/dest/jest/setupAfterEnv.js

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

package/dest/json-rpc/client/fetch.d.ts

@@ -0,0 +1,37 @@
+import { type Logger } from '../../log/index.js';
+export type JsonRpcFetch = (host: string, body: any, extraHeaders?: Record<string, string>, noRetry?: boolean) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>;
+export type JsonRpcFetchConfig = {
+    credentials?: RequestCredentials;
+};
+/**
+ * A normal fetch function that does not retry.
+ * Alternatives are a fetch function with retries, or a mocked fetch.
+ * @param host - The host URL.
+ * @param method - The RPC method name.
+ * @param body - The RPC payload.
+ * @param noRetry - Whether to throw a `NoRetryError` in case the response is a 5xx error and the body contains an error
+ *                  message (see `retry` function for more details).
+ * @param config - Fetch transport configuration.
+ * @returns The parsed JSON response, or throws an error.
+ */
+export declare function defaultFetch(host: string, body: unknown, extraHeaders?: Record<string, string>, noRetry?: boolean, config?: JsonRpcFetchConfig): Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>;
+/**
+ * Makes a fetch function that retries based on the given attempts.
+ * @param retries - Sequence of intervals (in seconds) to retry.
+ * @param noRetry - Whether to stop retries on server errors.
+ * @param log - Optional logger for logging attempts.
+ * @param config - Fetch transport configuration.
+ * @returns A fetch function.
+ */
+export declare function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger, config?: JsonRpcFetchConfig): JsonRpcFetch;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2guZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9qc29uLXJwYy9jbGllbnQvZmV0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLG9CQUFvQixDQUFDO0FBTS9ELE1BQU0sTUFBTSxZQUFZLEdBQUcsQ0FDekIsSUFBSSxFQUFFLE1BQU0sRUFDWixJQUFJLEVBQUUsR0FBRyxFQUNULFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQ3JDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sS0FDZCxPQUFPLENBQUM7SUFBRSxRQUFRLEVBQUUsR0FBRyxDQUFDO0lBQUMsT0FBTyxFQUFFO1FBQUUsR0FBRyxFQUFFLENBQUMsTUFBTSxFQUFFLE1BQU0sS0FBSyxNQUFNLEdBQUcsSUFBSSxHQUFHLFNBQVMsQ0FBQTtLQUFFLENBQUE7Q0FBRSxDQUFDLENBQUM7QUFFakcsTUFBTSxNQUFNLGtCQUFrQixHQUFHO0lBQy9CLFdBQVcsQ0FBQyxFQUFFLGtCQUFrQixDQUFDO0NBQ2xDLENBQUM7QUFFRjs7Ozs7Ozs7OztHQVVHO0FBQ0gsd0JBQXNCLFlBQVksQ0FDaEMsSUFBSSxFQUFFLE1BQU0sRUFDWixJQUFJLEVBQUUsT0FBTyxFQUNiLFlBQVksR0FBRSxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBTSxFQUN6QyxPQUFPLFVBQVEsRUFDZixNQUFNLEdBQUUsa0JBQXVCLEdBQzlCLE9BQU8sQ0FBQztJQUFFLFFBQVEsRUFBRSxHQUFHLENBQUM7SUFBQyxPQUFPLEVBQUU7UUFBRSxHQUFHLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxLQUFLLE1BQU0sR0FBRyxJQUFJLEdBQUcsU0FBUyxDQUFBO0tBQUUsQ0FBQTtDQUFFLENBQUMsQ0FvQzdGO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQixTQUFTLENBQ3ZCLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFDakIsY0FBYyxFQUFFLE9BQU8sRUFDdkIsR0FBRyxDQUFDLEVBQUUsTUFBTSxFQUNaLE1BQU0sR0FBRSxrQkFBdUIsR0FDOUIsWUFBWSxDQVVkIn0=

package/dest/json-rpc/client/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/client/fetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,oBAAoB,CAAC;AAM/D,MAAM,MAAM,YAAY,GAAG,CACzB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,GAAG,EACT,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAA;CAAE,CAAC,CAAC;AAEjG,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,EACb,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACzC,OAAO,UAAQ,EACf,MAAM,GAAE,kBAAuB,GAC9B,OAAO,CAAC;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,CAAA;CAAE,CAAC,CAoC7F;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EAAE,EACjB,cAAc,EAAE,OAAO,EACvB,GAAG,CAAC,EAAE,MAAM,EACZ,MAAM,GAAE,kBAAuB,GAC9B,YAAY,CAUd"}

package/dest/json-rpc/client/fetch.js

@@ -0,0 +1,67 @@
+import { format, inspect } from 'util';
+import { createLogger } from '../../log/index.js';
+import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
+import { jsonStringify } from '../convert.js';
+const log = createLogger('json-rpc:json_rpc_client');
+/**
+ * A normal fetch function that does not retry.
+ * Alternatives are a fetch function with retries, or a mocked fetch.
+ * @param host - The host URL.
+ * @param method - The RPC method name.
+ * @param body - The RPC payload.
+ * @param noRetry - Whether to throw a `NoRetryError` in case the response is a 5xx error and the body contains an error
+ *                  message (see `retry` function for more details).
+ * @param config - Fetch transport configuration.
+ * @returns The parsed JSON response, or throws an error.
+ */ export async function defaultFetch(host, body, extraHeaders = {}, noRetry = false, config = {}) {
+    log.debug(format(`JsonRpcClient.fetch`, host, '->', body));
+    let resp;
+    try {
+        resp = await fetch(host, {
+            method: 'POST',
+            body: jsonStringify(body),
+            headers: {
+                'content-type': 'application/json',
+                ...extraHeaders
+            },
+            credentials: config.credentials
+        });
+    } catch (err) {
+        const errorMessage = `Error fetching from host ${host}: ${inspect(err)}`;
+        throw new Error(errorMessage);
+    }
+    let responseJson;
+    const responseText = await resp.text();
+    try {
+        responseJson = JSON.parse(responseText);
+    } catch  {
+        if (!resp.ok) {
+            throw new Error(resp.statusText);
+        }
+        throw new Error(`Failed to parse body as JSON: ${responseText}`);
+    }
+    if (!resp.ok) {
+        const errorMessage = `Error ${resp.status} from server ${host}: ${responseJson?.error?.message ?? JSON.stringify(responseJson)}`;
+        if (noRetry || resp.status >= 400 && resp.status < 500) {
+            throw new NoRetryError(errorMessage);
+        } else {
+            throw new Error(errorMessage);
+        }
+    }
+    return {
+        response: responseJson,
+        headers: resp.headers
+    };
+}
+/**
+ * Makes a fetch function that retries based on the given attempts.
+ * @param retries - Sequence of intervals (in seconds) to retry.
+ * @param noRetry - Whether to stop retries on server errors.
+ * @param log - Optional logger for logging attempts.
+ * @param config - Fetch transport configuration.
+ * @returns A fetch function.
+ */ export function makeFetch(retries, defaultNoRetry, log, config = {}) {
+    return async (host, body, extraHeaders = {}, noRetry)=>{
+        return await retry(()=>defaultFetch(host, body, extraHeaders, noRetry ?? defaultNoRetry, config), `JsonRpcClient request to ${host}`, makeBackoff(retries), log, false);
+    };
+}

package/dest/json-rpc/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './safe_json_rpc_client.js';
+export * from './fetch.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9qc29uLXJwYy9jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLFlBQVksQ0FBQyJ9

package/dest/json-rpc/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC"}

package/dest/json-rpc/client/index.js

@@ -0,0 +1,2 @@
+export * from './safe_json_rpc_client.js';
+export * from './fetch.js';

package/dest/json-rpc/client/safe_json_rpc_client.d.ts

@@ -0,0 +1,33 @@
+import { type Logger } from '../../log/pino-logger.js';
+import { type ApiSchemaFor } from '../../schemas/api.js';
+import { type JsonRpcFetch } from './fetch.js';
+export type SafeJsonRpcClientOptions = {
+    namespaceMethods?: string | false;
+    fetch?: JsonRpcFetch;
+    log?: Logger;
+    batchWindowMS?: number;
+    maxBatchSize?: number;
+    maxRequestBodySize?: number;
+    extraHeaders?: Record<string, string>;
+    onResponse?: (res: {
+        response: any;
+        headers: {
+            get: (header: string) => string | null | undefined;
+        };
+    }) => 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 fetch - The fetch implementation to use.
+ */
+export declare function createSafeJsonRpcClient<T extends object>(host: string, schema: ApiSchemaFor<T>, config?: SafeJsonRpcClientOptions): T;
+/**
+ * Triggers a batch to be sent immediately
+ */
+export declare function batch<T extends readonly unknown[]>(values: T): Promise<{
+    -readonly [P in keyof T]: Awaited<T[P]>;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZV9qc29uX3JwY19jbGllbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9qc29uLXJwYy9jbGllbnQvc2FmZV9qc29uX3JwY19jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLDBCQUEwQixDQUFDO0FBRXJFLE9BQU8sRUFBa0IsS0FBSyxZQUFZLEVBQXdDLE1BQU0sc0JBQXNCLENBQUM7QUFFL0csT0FBTyxFQUFFLEtBQUssWUFBWSxFQUFnQixNQUFNLFlBQVksQ0FBQztBQWM3RCxNQUFNLE1BQU0sd0JBQXdCLEdBQUc7SUFDckMsZ0JBQWdCLENBQUMsRUFBRSxNQUFNLEdBQUcsS0FBSyxDQUFDO0lBQ2xDLEtBQUssQ0FBQyxFQUFFLFlBQVksQ0FBQztJQUNyQixHQUFHLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDYixhQUFhLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdkIsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLGtCQUFrQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzVCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDdEMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUU7UUFDakIsUUFBUSxFQUFFLEdBQUcsQ0FBQztRQUNkLE9BQU8sRUFBRTtZQUFFLEdBQUcsRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEtBQUssTUFBTSxHQUFHLElBQUksR0FBRyxTQUFTLENBQUE7U0FBRSxDQUFDO0tBQ2pFLEtBQUssT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQ3JCLENBQUM7QUE2QkY7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLHVCQUF1QixDQUFDLENBQUMsU0FBUyxNQUFNLEVBQ3RELElBQUksRUFBRSxNQUFNLEVBQ1osTUFBTSxFQUFFLFlBQVksQ0FBQyxDQUFDLENBQUMsRUFDdkIsTUFBTSxHQUFFLHdCQUE2QixHQUNwQyxDQUFDLENBb0xIO0FBRUQ7O0dBRUc7QUFDSCx3QkFBc0IsS0FBSyxDQUFDLENBQUMsU0FBUyxTQUFTLE9BQU8sRUFBRSxFQUN0RCxNQUFNLEVBQUUsQ0FBQyxHQUNSLE9BQU8sQ0FBQztJQUFFLENBQUMsVUFBVSxDQUFDLElBQUksTUFBTSxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztDQUFFLENBQUMsQ0F1QnREIn0=

package/dest/json-rpc/client/safe_json_rpc_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe_json_rpc_client.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/client/safe_json_rpc_client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAAkB,KAAK,YAAY,EAAwC,MAAM,sBAAsB,CAAC;AAE/G,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,YAAY,CAAC;AAc7D,MAAM,MAAM,wBAAwB,GAAG;IACrC,gBAAgB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAClC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE;QACjB,QAAQ,EAAE,GAAG,CAAC;QACd,OAAO,EAAE;YAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;SAAE,CAAC;KACjE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB,CAAC;AA6BF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EACtD,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,MAAM,GAAE,wBAA6B,GACpC,CAAC,CAoLH;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EACtD,MAAM,EAAE,CAAC,GACR,OAAO,CAAC;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAuBtD"}

package/dest/json-rpc/client/safe_json_rpc_client.js

@@ -0,0 +1,218 @@
+import { format } from 'util';
+import { createLogger } from '../../log/pino-logger.js';
+import { promiseWithResolvers } from '../../promise/utils.js';
+import { getSchemaReturnType, schemaHasMethod } from '../../schemas/api.js';
+import { jsonStringify } from '../convert.js';
+import { 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;
+// 1 mb, matching the JSON-RPC server's default maxBodySizeBytes so the client never assembles a batch the
+// server rejects for exceeding the body limit
+const DEFAULT_MAX_REQUESTY_BODY_SIZE = 1 * 1024 * 1024;
+// 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();
+/**
+ * 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 fetch - The fetch implementation to use.
+ */ export function createSafeJsonRpcClient(host, schema, config = {}) {
+    const fetch = config.fetch ?? defaultFetch;
+    const log = config.log ?? createLogger('json-rpc:client');
+    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;
+    const queue = [];
+    const sendBatch = async ()=>{
+        if (sendBatchTimeoutHandle !== undefined) {
+            clearTimeout(sendBatchTimeoutHandle);
+            sendBatchTimeoutHandle = undefined;
+        }
+        const rpcCalls = [];
+        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), config.extraHeaders);
+            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 = 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.message ?? 'Failed request'
+                    }
+                });
+            }
+        }
+    };
+    const request = async (methodName, params)=>{
+        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 deferred = promiseWithResolvers();
+        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 = await deferred.promise;
+        log.debug(format(`result`, method, response));
+        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)) {
+            return;
+        }
+        return getSchemaReturnType(schema[methodName]).parseAsync(response.result);
+    };
+    const clientId = nextClientId++;
+    const proxy = {
+        [CLIENT_ID]: clientId,
+        [SEND_BATCH]: sendBatch
+    };
+    for (const method of Object.keys(schema)){
+        // attach the clientId to the promise so that if we want to trigger a batch immediately, we can do that
+        proxy[method] = (...params)=>Object.assign(request(method, params), {
+                [CLIENT_ID]: clientId
+            });
+    }
+    clients.set(clientId, new WeakRef(proxy));
+    return proxy;
+}
+/**
+ * Triggers a batch to be sent immediately
+ */ export async function batch(values) {
+    const clientIdsSeen = new Set();
+    await Promise.allSettled(values.map((val)=>{
+        if (typeof val === 'object' && val && Object.hasOwn(val, CLIENT_ID)) {
+            const clientId = val[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);
+}

package/dest/json-rpc/client/undici.d.ts

@@ -0,0 +1,16 @@
+import { Agent, type Dispatcher } from 'undici';
+import type { JsonRpcFetch } from './fetch.js';
+export { Agent };
+/** Asynchronous cookie storage. */
+export interface CookieJar {
+    getCookieString(url: string): Promise<string>;
+    setCookie(cookie: string, url: string): Promise<unknown>;
+}
+/**
+ * Creates an Undici JSON-RPC transport.
+ * @param client - Dispatcher used to make requests.
+ * @param cookieJar - Optional application-owned cookie storage. Cookies are ignored when omitted.
+ * @returns A JSON-RPC fetch implementation.
+ */
+export declare function makeUndiciFetch(client?: Dispatcher, cookieJar?: CookieJar): JsonRpcFetch;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5kaWNpLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvanNvbi1ycGMvY2xpZW50L3VuZGljaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssVUFBVSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBS2hELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQVUvQyxPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFFakIsbUNBQW1DO0FBQ25DLE1BQU0sV0FBVyxTQUFTO0lBQ3hCLGVBQWUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM5QyxTQUFTLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztDQUMxRDtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQWdCLGVBQWUsQ0FBQyxNQUFNLEdBQUUsVUFBd0IsRUFBRSxTQUFTLENBQUMsRUFBRSxTQUFTLEdBQUcsWUFBWSxDQWdHckcifQ==

package/dest/json-rpc/client/undici.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undici.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/client/undici.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAC;AAKhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAU/C,OAAO,EAAE,KAAK,EAAE,CAAC;AAEjB,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,GAAE,UAAwB,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,YAAY,CAgGrG"}