@aztec/foundation 0.71.0 → 0.72.1

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

@@ -21,6 +21,7 @@ export async function defaultFetch(
   rpcMethod: string,
   body: any,
   useApiEndpoints: boolean,
+  extraHeaders: Record<string, string> = {},
   noRetry = false,
 ) {
   log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
@@ -30,13 +31,13 @@ export async function defaultFetch(
       resp = await fetch(`${host}/${rpcMethod}`, {
         method: 'POST',
         body: jsonStringify(body),
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', ...extraHeaders },
       });
     } else {
       resp = await fetch(host, {
         method: 'POST',
         body: jsonStringify({ ...body, method: rpcMethod }),
-        headers: { 'content-type': 'application/json' },
+        headers: { 'content-type': 'application/json', ...extraHeaders },
       });
     }
   } catch (err) {
@@ -55,7 +56,7 @@ export async function defaultFetch(
   }
 
   if (!resp.ok) {
-    const errorMessage = `(JSON-RPC PROPAGATED) (host ${host}) (method ${rpcMethod}) (code ${resp.status}) ${responseJson.error.message}`;
+    const errorMessage = `Error ${resp.status} from server ${host} on ${rpcMethod}: ${responseJson.error.message}`;
     if (noRetry || (resp.status >= 400 && resp.status < 500)) {
       throw new NoRetryError(errorMessage);
     } else {
@@ -73,10 +74,17 @@ export async function defaultFetch(
  * @param log - Optional logger for logging attempts.
  * @returns A fetch function.
  */
-export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger) {
-  return async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, noRetry?: boolean) => {
+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 await retry(
-      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, noRetry ?? defaultNoRetry),
+      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, extraHeaders, noRetry ?? defaultNoRetry),
       `JsonRpcClient request ${rpcMethod} to ${host}`,
       makeBackoff(retries),
       log,

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

@@ -40,7 +40,6 @@ export function createSafeJsonRpcClient<T extends object>(
     if ([null, undefined, 'null', 'undefined'].includes(res.result)) {
       return;
     }
-
     return (schema as ApiSchema)[methodName].returnType().parse(res.result);
   };
 

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

@@ -1,6 +1,6 @@
 import cors from '@koa/cors';
 import http from 'http';
-import Koa from 'koa';
+import { type default as Application, default as Koa } from 'koa';
 import bodyParser from 'koa-bodyparser';
 import compress from 'koa-compress';
 import Router from 'koa-router';
@@ -14,6 +14,15 @@ import { type ApiSchema, type ApiSchemaFor, parseWithOptionals, schemaHasMethod
 import { jsonStringify } from '../convert.js';
 import { assert } from '../js_utils.js';
 
+export type DiagnosticsData = {
+  id: number | string | null;
+  method: string;
+  params: any[];
+  headers: http.IncomingHttpHeaders;
+};
+
+export type DiagnosticsMiddleware = (ctx: DiagnosticsData, next: () => Promise<void>) => Promise<void>;
+
 export class SafeJsonRpcServer {
   /**
    * The HTTP server accepting remote requests.
@@ -31,6 +40,8 @@ export class SafeJsonRpcServer {
     private http200OnError = false,
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
+    /** Additional middlewares */
+    private extraMiddlewares: Application.Middleware[] = [],
     /** Logger */
     private log = createLogger('json-rpc:server'),
   ) {}
@@ -90,8 +101,11 @@ export class SafeJsonRpcServer {
       this.log.error(`Error on API handler: ${error}`);
     });
 
-    app.use(compress({ br: false } as any));
+    app.use(compress({ br: false }));
     app.use(jsonResponse);
+    for (const middleware of this.extraMiddlewares) {
+      app.use(middleware);
+    }
     app.use(exceptionHandler);
     app.use(bodyParser({ jsonLimit: '50mb', enableTypes: ['json'], detectJSON: () => true }));
     app.use(cors());
@@ -114,7 +128,9 @@ export class SafeJsonRpcServer {
       // Fail if not a registered function in the proxy
       if (typeof method !== 'string' || method === 'constructor' || !this.proxy.hasMethod(method)) {
         ctx.status = 400;
-        ctx.body = { jsonrpc, id, error: { code: -32601, message: `Method not found: ${method}` } };
+        const code = -32601;
+        const message = `Method not found: ${method}`;
+        ctx.body = { jsonrpc, id, error: { code, message } };
       } else {
         ctx.status = 200;
         const result = await this.proxy.call(method, params);
@@ -263,10 +279,11 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Lo
   };
 }
 
-type SafeJsonRpcServerOptions = {
+export type SafeJsonRpcServerOptions = {
   http200OnError: boolean;
   healthCheck?: StatusCheckFn;
   log?: Logger;
+  middlewares?: Application.Middleware[];
 };
 
 /**
@@ -276,25 +293,24 @@ type SafeJsonRpcServerOptions = {
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
-  options: Omit<SafeJsonRpcServerOptions, 'healthcheck'> = {
-    http200OnError: false,
+  options: Partial<Omit<SafeJsonRpcServerOptions, 'healthcheck'>> = {
     log: createLogger('json-rpc:server'),
   },
 ): SafeJsonRpcServer {
-  const { http200OnError, log } = options;
+  const { middlewares, http200OnError, log } = options;
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);
-  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, log);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, middlewares, log);
 }
 
 export function createSafeJsonRpcServer<T extends object = any>(
   handler: T,
   schema: ApiSchemaFor<T>,
-  options: SafeJsonRpcServerOptions = { http200OnError: false },
+  options: Partial<SafeJsonRpcServerOptions> = {},
 ) {
-  const { http200OnError, log, healthCheck } = options;
+  const { http200OnError, log, healthCheck, middlewares: extraMiddlewares } = options;
   const proxy = new SafeJsonProxy(handler, schema);
-  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, log);
+  return new SafeJsonRpcServer(proxy, http200OnError, healthCheck, extraMiddlewares, log);
 }
 
 /**

package/src/testing/files/index.ts

@@ -6,12 +6,12 @@ import { fileURLToPath } from '../../url/index.js';
 import { isGenerateTestDataEnabled } from '../test_data.js';
 
 /** Writes the contents specified to the target file if test data generation is enabled. */
-export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer) {
+export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer, raw: boolean = false) {
   if (!isGenerateTestDataEnabled()) {
     return;
   }
   const targetFile = getPathToFile(targetFileFromRepoRoot);
-  const toWrite = typeof contents === 'string' ? contents : contents.toString('hex');
+  const toWrite = raw ? contents : typeof contents === 'string' ? contents : contents.toString('hex');
   writeFileSync(targetFile, toWrite);
   const logger = createConsoleLogger('aztec:testing:test_data');
   logger(`Wrote test data to ${targetFile}`);

package/src/timer/timeout.ts

@@ -27,7 +27,7 @@ export class TimeoutTask<T> {
    * @throws An error with a message indicating the function was interrupted due to exceeding the specified timeout.
    */
   public async exec() {
-    const interruptTimeout = !this.timeout ? 0 : setTimeout(this.interrupt, this.timeout);
+    const interruptTimeout = setTimeout(this.interrupt, this.timeout);
     try {
       const start = Date.now();
       const result = await Promise.race<T>([this.fn(), this.interruptPromise]);