@aztec/foundation 0.7.9 → 0.8.4

package/src/json-rpc/convert.ts

@@ -88,7 +88,7 @@ export function convertFromJsonObj(cc: ClassConverter, obj: any): any {
     if (cc.isRegisteredClassName(obj.type)) {
       return cc.toClassObj(obj);
     } else {
-      throw new Error(`Object ${obj.type} not registered for serialisation FROM JSON`);
+      throw new Error(`Object ${obj.type} not registered for serialization FROM JSON`);
     }
   }
 
@@ -117,6 +117,14 @@ export function convertFromJsonObj(cc: ClassConverter, obj: any): any {
  * @returns The encoded object.
  */
 export function convertToJsonObj(cc: ClassConverter, obj: any): any {
+  // Bigint is a primitive type that needs special handling since it's not serialisable
+  if (typeof obj === 'bigint') {
+    return {
+      type: 'bigint',
+      data: obj.toString(),
+    };
+  }
+
   if (!obj) {
     return obj; // Primitive type
   }
@@ -126,13 +134,6 @@ export function convertToJsonObj(cc: ClassConverter, obj: any): any {
     return { type: 'Buffer', data: obj.toString('base64') };
   }
 
-  if (typeof obj === 'bigint') {
-    return {
-      type: 'bigint',
-      data: obj.toString(),
-    };
-  }
-
   // Is this a convertible type?
   if (cc.isRegisteredClass(obj.constructor)) {
     return cc.toJsonObj(obj);
@@ -153,7 +154,7 @@ export function convertToJsonObj(cc: ClassConverter, obj: any): any {
       return newObj;
     } else {
       // Throw if this is a non-primitive class that was not registered
-      throw new Error(`Object ${obj.constructor.name} not registered for serialisation TO JSON`);
+      throw new Error(`Object ${obj.constructor.name} not registered for serialization TO JSON`);
     }
   }
 

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

@@ -1,3 +1,5 @@
+import { format } from 'util';
+
 import { createDebugLogger } from '../../log/index.js';
 import { ClassConverter, JsonClassConverterInput, StringClassConverterInput } from '../class_converter.js';
 import { convertFromJsonObj, convertToJsonObj } from '../convert.js';
@@ -25,17 +27,17 @@ export class JsonProxy {
    * @returns The remote result.
    */
   public async call(methodName: string, jsonParams: any[] = []) {
-    debug(`JsonProxy:call`, methodName, jsonParams);
+    debug(format(`JsonProxy:call`, methodName, jsonParams));
     // Get access to our class members
     const proto = Object.getPrototypeOf(this.handler);
     assert(hasOwnProperty(proto, methodName), `JsonProxy: Method ${methodName} not found!`);
     assert(Array.isArray(jsonParams), 'JsonProxy: Params not an array!');
     // convert the params from json representation to classes
     const convertedParams = jsonParams.map(param => convertFromJsonObj(this.classConverter, param));
-    debug('JsonProxy:call', methodName, '<-', convertedParams);
+    debug(format('JsonProxy:call', methodName, '<-', convertedParams));
     const rawRet = await (this.handler as any)[methodName](...convertedParams);
     const ret = convertToJsonObj(this.classConverter, rawRet);
-    debug('JsonProxy:call', methodName, '->', ret);
+    debug(format('JsonProxy:call', methodName, '->', ret));
     return ret;
   }
 }

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

@@ -39,22 +39,43 @@ export class JsonRpcServer {
         await next();
       } catch (err: any) {
         this.log.error(err);
-        ctx.status = 400;
-        ctx.body = { error: err.message };
+        if (err instanceof SyntaxError) {
+          ctx.status = 400;
+          ctx.body = {
+            jsonrpc: '2.0',
+            id: null,
+            error: {
+              code: -32700,
+              message: 'Parse error',
+            },
+          };
+        } else {
+          ctx.status = 500;
+          ctx.body = {
+            jsonrpc: '2.0',
+            id: null,
+            error: {
+              code: -32603,
+              message: 'Internal error',
+            },
+          };
+        }
       }
     };
     const app = new Koa();
     app.on('error', error => {
       this.log.error(`Error on API handler: ${error}`);
     });
+    app.use(exceptionHandler);
     app.use(compress({ br: false } as any));
     app.use(
       bodyParser({
         jsonLimit: '10mb',
+        enableTypes: ['json'],
+        detectJSON: () => true,
       }),
     );
     app.use(cors());
-    app.use(exceptionHandler);
     app.use(router.routes());
     app.use(router.allowedMethods());
 
@@ -96,7 +117,15 @@ export class JsonRpcServer {
             // Propagate the error message to the client. Plenty of the errors are expected to occur (e.g. adding
             // a duplicate recipient) so this is necessary.
             ctx.status = 400;
-            ctx.body = { error: err.message };
+            ctx.body = {
+              jsonrpc,
+              id,
+              error: {
+                // TODO assign error codes - https://github.com/AztecProtocol/aztec-packages/issues/2633
+                code: -32000,
+                message: err.message,
+              },
+            };
           }
         });
       }
@@ -111,7 +140,14 @@ export class JsonRpcServer {
           this.disallowedMethods.includes(method)
         ) {
           ctx.status = 400;
-          ctx.body = { error: `Invalid method name: ${method}` };
+          ctx.body = {
+            jsonrpc,
+            id,
+            error: {
+              code: -32601,
+              message: 'Method not found',
+            },
+          };
         } else {
           try {
             const result = await this.proxy.call(method, params);
@@ -125,7 +161,15 @@ export class JsonRpcServer {
             // Propagate the error message to the client. Plenty of the errors are expected to occur (e.g. adding
             // a duplicate recipient) so this is necessary.
             ctx.status = 400;
-            ctx.body = { error: err.message };
+            ctx.body = {
+              jsonrpc,
+              id,
+              error: {
+                // TODO assign error codes - https://github.com/AztecProtocol/aztec-packages/issues/2633
+                code: -32000,
+                message: err.message,
+              },
+            };
           }
         }
       });

package/src/log/index.ts

@@ -1,7 +1,8 @@
-/**
- * A callable logger instance.
- */
-export type LogFn = (...args: any[]) => void;
+/** Structured log data to include with the message. */
+export type LogData = Record<string, string | number | bigint | boolean>;
+
+/** A callable logger instance. */
+export type LogFn = (msg: string, data?: LogData) => void;
 
 export * from './console.js';
 export * from './debug.js';

package/src/log/logger.ts

@@ -2,24 +2,27 @@ import debug from 'debug';
 import isNode from 'detect-node';
 import { isatty } from 'tty';
 
-import { LogFn } from './index.js';
+import { LogData, LogFn } from './index.js';
 
 // Matches a subset of Winston log levels
 const LogLevels = ['silent', 'error', 'warn', 'info', 'verbose', 'debug'] as const;
-const DefaultLogLevel = 'info' as const;
+const DefaultLogLevel = process.env.NODE_ENV === 'test' ? ('silent' as const) : ('info' as const);
 
 /**
  * A valid log severity level.
  */
-type LogLevel = (typeof LogLevels)[number];
+export type LogLevel = (typeof LogLevels)[number];
 
 const envLogLevel = process.env.LOG_LEVEL?.toLowerCase() as LogLevel;
 const currentLevel = LogLevels.includes(envLogLevel) ? envLogLevel : DefaultLogLevel;
 
+/** Log function that accepts an exception object */
+type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
+
 /**
  * Logger that supports multiple severity levels.
  */
-export type Logger = { [K in LogLevel]: LogFn };
+export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ error: ErrorLogFn };
 
 /**
  * Logger that supports multiple severity levels and can be called directly to issue a debug statement.
@@ -40,17 +43,17 @@ export function createDebugLogger(name: string): DebugLogger {
 
   const logger = {
     silent: () => {},
-    error: (...args: any[]) => logWithDebug(debugLogger, 'error', args),
-    warn: (...args: any[]) => logWithDebug(debugLogger, 'warn', args),
-    info: (...args: any[]) => logWithDebug(debugLogger, 'info', args),
-    verbose: (...args: any[]) => logWithDebug(debugLogger, 'verbose', args),
-    debug: (...args: any[]) => logWithDebug(debugLogger, 'debug', args),
+    error: (msg: string, err?: unknown, data?: LogData) => logWithDebug(debugLogger, 'error', fmtErr(msg, err), data),
+    warn: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'warn', msg, data),
+    info: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'info', msg, data),
+    verbose: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'verbose', msg, data),
+    debug: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'debug', msg, data),
   };
-  return Object.assign((...args: any[]) => logWithDebug(debugLogger, 'debug', args), logger);
+  return Object.assign((msg: string, data?: LogData) => logWithDebug(debugLogger, 'debug', msg, data), logger);
 }
 
 /** A callback to capture all logs. */
-export type LogHandler = (level: LogLevel, namespace: string, args: any[]) => void;
+export type LogHandler = (level: LogLevel, namespace: string, msg: string, data?: LogData) => void;
 
 const logHandlers: LogHandler[] = [];
 
@@ -68,14 +71,16 @@ export function onLog(handler: LogHandler) {
  * @param level - Intended log level.
  * @param args - Args to log.
  */
-function logWithDebug(debug: debug.Debugger, level: LogLevel, args: any[]) {
+function logWithDebug(debug: debug.Debugger, level: LogLevel, msg: string, data?: LogData) {
   for (const handler of logHandlers) {
-    handler(level, debug.namespace, args);
+    handler(level, debug.namespace, msg, data);
   }
+
+  const msgWithData = data ? `${msg} ${fmtLogData(data)}` : msg;
   if (debug.enabled) {
-    debug(args[0], ...args.slice(1));
-  } else if (LogLevels.indexOf(level) <= LogLevels.indexOf(currentLevel) && process.env.NODE_ENV !== 'test') {
-    printLog([getPrefix(debug, level), ...args]);
+    debug(msgWithData);
+  } else if (LogLevels.indexOf(level) <= LogLevels.indexOf(currentLevel)) {
+    printLog(`${getPrefix(debug, level)} ${msgWithData}`);
   }
 }
 
@@ -96,9 +101,30 @@ function getPrefix(debugLogger: debug.Debugger, level: LogLevel) {
 
 /**
  * Outputs to console error.
- * @param args - Args to log.
+ * @param msg - What to log.
  */
-function printLog(args: any[]) {
+function printLog(msg: string) {
   // eslint-disable-next-line no-console
-  console.error(...args);
+  console.error(msg);
+}
+
+/**
+ * Concatenates a log message and an exception.
+ * @param msg - Log message
+ * @param err - Error to log
+ * @returns A string with both the log message and the error message.
+ */
+function fmtErr(msg: string, err?: Error | unknown): string {
+  const errStr = err && [(err as Error).name, (err as Error).message].filter(x => !!x).join(' ');
+  return err ? `${msg}: ${errStr || err}` : msg;
+}
+
+/**
+ * Formats structured log data as a string for console output.
+ * @param data - Optional log data.
+ */
+function fmtLogData(data?: LogData): string {
+  return Object.entries(data ?? {})
+    .map(([key, value]) => `${key}=${value}`)
+    .join(' ');
 }

package/src/timer/elapsed.ts

@@ -0,0 +1,23 @@
+import { Timer } from './timer.js';
+
+/**
+ * Measures the elapsed execution time of a function call or promise once it is awaited.
+ * @param fn - Function or promise.
+ * @returns A timer object and the result.
+ */
+export async function elapsed<T>(fn: Promise<T> | (() => T | Promise<T>)): Promise<[Timer, T]> {
+  const timer = new Timer();
+  const result = await (typeof fn === 'function' ? fn() : fn);
+  return [timer, result];
+}
+
+/**
+ * Measures the elapsed execution time of a synchronous function call once it is awaited.
+ * @param fn - Function.
+ * @returns A timer object and the result.
+ */
+export function elapsedSync<T>(fn: () => T): [Timer, T] {
+  const timer = new Timer();
+  const result = fn();
+  return [timer, result];
+}

package/src/timer/index.ts

@@ -1,2 +1,3 @@
 export { TimeoutTask } from './timeout.js';
 export { Timer } from './timer.js';
+export { elapsed, elapsedSync } from './elapsed.js';

package/src/transport/dispatch/create_dispatch_fn.ts

@@ -1,3 +1,5 @@
+import { format } from 'util';
+
 import { createDebugLogger } from '../../log/index.js';
 
 /**
@@ -27,7 +29,7 @@ export interface DispatchMsg {
 export function createDispatchFn(targetFn: () => any, debug = createDebugLogger('aztec:foundation:dispatch')) {
   return async ({ fn, args }: DispatchMsg) => {
     const target = targetFn();
-    debug(`dispatching to ${target}: ${fn}`, args);
+    debug(format(`dispatching to ${target}: ${fn}`, args));
     return await target[fn](...args);
   };
 }

package/src/transport/transport_client.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'events';
+import { format } from 'util';
 
 import { createDebugLogger } from '../log/index.js';
 import { EventMessage, ResponseMessage, isEventMessage } from './dispatch/messages.js';
@@ -91,7 +92,7 @@ export class TransportClient<Payload> extends EventEmitter {
     }
     const msgId = this.msgId++;
     const msg = { msgId, payload };
-    debug(`->`, msg);
+    debug(format(`->`, msg));
     return new Promise<any>((resolve, reject) => {
       this.pendingRequests.push({ resolve, reject, msgId });
       this.socket!.send(msg, transfer).catch(reject);
@@ -111,7 +112,7 @@ export class TransportClient<Payload> extends EventEmitter {
       this.close();
       return;
     }
-    debug(`<-`, msg);
+    debug(format(`<-`, msg));
     if (isEventMessage(msg)) {
       this.emit('event_msg', msg.payload);
       return;

package/src/wasm/wasm_module.ts

@@ -149,9 +149,9 @@ export class WasmModule implements IWasmModule {
    */
   public addLogger(logger: LogFn) {
     const oldDebug = this.debug;
-    this.debug = (...args: any[]) => {
-      logger(...args);
-      oldDebug(...args);
+    this.debug = (msg: string) => {
+      logger(msg);
+      oldDebug(msg);
     };
   }
 

package/.eslintrc.cjs

@@ -1,134 +0,0 @@
-// See https://typescript-eslint.io/play/#ts=5.1.6&showAST=es&fileType=.ts
-const contexts = [
-  // All methods in an interface
-  'TSInterfaceDeclaration TSMethodSignature',
-  // All public methods in a class that does not implement an interface
-  'ClassDeclaration[implements.length=0] MethodDefinition[accessibility=public]',
-  // TODO: All methods public by default in a class that does not implement an interface
-  // 'ClassDeclaration[implements.length=0] MethodDefinition[accessibility=undefined][key.type=Identifier]',
-  // TODO: All export const from the top level of a file
-  // 'ExportNamedDeclaration[declaration.type=VariableDeclaration]',
-  // Legacy contexts (needs review)
-  'TSParameterProperty[accessibility=public]',
-  'TSPropertySignature',
-  'PropertySignature',
-  'TSInterfaceDeclaration',
-  'InterfaceDeclaration',
-  'TSPropertyDefinition[accessibility=public]',
-  'PropertyDefinition[accessibility=public]',
-  'TSTypeAliasDeclaration',
-  'TypeAliasDeclaration',
-  'TSTypeDeclaration',
-  'TypeDeclaration',
-  'TSEnumDeclaration',
-  'EnumDeclaration',
-  'TSClassDeclaration',
-  'ClassDeclaration',
-  'TSClassExpression',
-  'ClassExpression',
-  'TSFunctionExpression',
-  'FunctionExpression',
-  'TSInterfaceExpression',
-  'InterfaceExpression',
-  'TSEnumExpression',
-  'EnumExpression',
-];
-
-const JSDOC_RULES_LEVEL = 'error';
-
-module.exports = {
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:import/recommended',
-    'plugin:import/typescript',
-    'prettier',
-  ],
-  settings: {
-    'import/resolver': {
-      typescript: true,
-      node: true,
-    },
-  },
-  root: true,
-  parser: '@typescript-eslint/parser',
-  plugins: ['@typescript-eslint', 'eslint-plugin-tsdoc', 'jsdoc'],
-  overrides: [
-    {
-      files: ['*.ts', '*.tsx'],
-      parserOptions: {
-        // hacky workaround for CI not having the same tsconfig setup
-        project: true,
-      },
-    },
-    {
-      files: '*.test.ts',
-      rules: {
-        'jsdoc/require-jsdoc': 'off',
-      },
-    },
-  ],
-  env: {
-    node: true,
-  },
-  rules: {
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/no-empty-function': 'off',
-    '@typescript-eslint/await-thenable': 'error',
-    '@typescript-eslint/no-floating-promises': 2,
-    '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-    'require-await': 2,
-    'no-console': 'error',
-    'no-constant-condition': 'off',
-    camelcase: 2,
-    'no-restricted-imports': [
-      'error',
-      {
-        patterns: [
-          {
-            group: ['client-dest'],
-            message: "Fix this absolute garbage import. It's your duty to solve it before it spreads.",
-          },
-          {
-            group: ['dest'],
-            message: 'You should not be importing from a build directory. Did you accidentally do a relative import?',
-          },
-        ],
-      },
-    ],
-    'import/no-unresolved': [
-      'error',
-      {
-        ignore: [
-          // See https://github.com/import-js/eslint-plugin-import/issues/2703
-          '@libp2p/bootstrap',
-          // Seems like ignoring l1-artifacts in the eslint call messes up no-unresolved
-          '@aztec/l1-artifacts',
-        ],
-      },
-    ],
-    'import/no-extraneous-dependencies': 'error',
-    'tsdoc/syntax': JSDOC_RULES_LEVEL,
-    'jsdoc/require-jsdoc': [
-      JSDOC_RULES_LEVEL,
-      {
-        contexts,
-        checkConstructors: false,
-        checkGetters: true,
-        checkSetters: true,
-      },
-    ],
-    'jsdoc/require-description': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-hyphen-before-param-description': [JSDOC_RULES_LEVEL],
-    'jsdoc/require-param': [JSDOC_RULES_LEVEL, { contexts, checkDestructured: false }],
-    'jsdoc/require-param-description': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-param-name': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-property': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-property-description': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-property-name': [JSDOC_RULES_LEVEL, { contexts }],
-    'jsdoc/require-returns': 'off',
-  },
-  ignorePatterns: ['node_modules', 'dest*', 'dist', '*.js', '.eslintrc.cjs'],
-};

package/.prettierrc.json

@@ -1,10 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all",
-  "printWidth": 120,
-  "arrowParens": "avoid",
-  "importOrder": ["^@aztec/(.*)$", "<THIRD_PARTY_MODULES>", "^\\./|\\.\\./"],
-  "importOrderSeparation": true,
-  "importOrderSortSpecifiers": true,
-  "importOrderParserPlugins": ["importAssertions", "typescript"]
-}