@aztec/foundation 0.61.0 → 0.63.0

package/src/json-rpc/class_converter.ts

@@ -1,213 +0,0 @@
-import { assert } from './js_utils.js';
-
-/**
- * Represents a class compatible with our class conversion system.
- * E.g. PublicKey here satisfies 'StringIOClass'.
- * ```
- *    class PublicKey {
- *      toString() {
- *        return '...';
- *      }
- *      static fromString(str) {
- *        return new PublicKey(...);
- *      }
- *    }
- * ```
- */
-interface StringIOClass {
-  new (...args: any): any;
-
-  // TODO(#4254): Ensure that toString method is checked for as well.
-
-  /**
-   * Creates an IOClass from a given string.
-   */
-  fromString: (str: string) => any;
-}
-
-/**
- * Represents a class compatible with our class conversion system.
- * E.g. PublicKey here satisfies 'ObjIOClass'.
- * ```
- *    class PublicKey {
- *      toJSON() {
- *        return {...};
- *      }
- *      static fromJSON(obj) {
- *        return new PublicKey({...});
- *      }
- *    }
- * ```
- */
-interface ObjIOClass {
-  new (...args: any): any;
-
-  // TODO(#4254): Ensure that toJSON method is checked for as well.
-
-  /**
-   * Creates an IOClass from a given JSON object.
-   */
-  fromJSON: (str: object) => any;
-}
-
-/**
- * Either a StringIOClass or ObjIOClass
- */
-type IOClass = ObjIOClass | StringIOClass;
-
-/**
- * Registered classes available for conversion.
- */
-export interface StringClassConverterInput {
-  [className: string]: StringIOClass;
-}
-
-/**
- * Registered classes available for conversion.
- */
-export interface JsonClassConverterInput {
-  [className: string]: ObjIOClass;
-}
-
-/**
- * Represents a class in a JSON-friendly encoding.
- */
-export interface StringEncodedClass {
-  /**
-   * The class type.
-   */
-  type: string;
-  /**
-   * The class data string.
-   */
-  data: string;
-}
-
-/**
- * Represents a class in a JSON-friendly encoding.
- */
-export interface JsonEncodedClass {
-  /**
-   * The class type.
-   */
-  type: string;
-  /**
-   * The class data string.
-   */
-  data: object;
-}
-/**
- * Whether a class is a complex object or simply represented by a string.
- */
-export type ClassEncoding = 'string' | 'object';
-
-/**
- * Handles mapping of classes to names, and calling toString and fromString to convert to and from JSON-friendly formats.
- * Takes a class map as input.
- */
-export class ClassConverter {
-  private toClass = new Map<string, [IOClass, ClassEncoding]>();
-  private toName = new Map<IOClass, [string, ClassEncoding]>();
-
-  /**
-   * Create a class converter from a table of classes.
-   * @param stringClassMap - The class table of string encoded classes.
-   * @param objectClassMap - The class table of complex object classes
-   */
-  constructor(stringClassMap?: StringClassConverterInput, objectClassMap?: JsonClassConverterInput) {
-    if (stringClassMap) {
-      for (const key of Object.keys(stringClassMap)) {
-        this.register(key, stringClassMap[key], 'string');
-      }
-    }
-    if (objectClassMap) {
-      for (const key of Object.keys(objectClassMap)) {
-        this.register(key, objectClassMap[key], 'object');
-      }
-    }
-  }
-
-  /**
-   * Register a class with a certain name.
-   * This name is used for conversion from and to this class.
-   * @param type - The class name to use for serialization.
-   * @param class_ - The class object.
-   * @param encoding - Whether the class is a complex object or simply represented by a string.
-   */
-  register(type: string, class_: IOClass, encoding: ClassEncoding) {
-    assert(type !== 'Buffer', "'Buffer' handling is hardcoded. Cannot use as name.");
-    assert(
-      class_.prototype['toString'] || class_.prototype['toJSON'],
-      `Class ${type} must define a toString() OR toJSON() method.`,
-    );
-    assert(
-      (class_ as StringIOClass)['fromString'] || (class_ as ObjIOClass)['fromJSON'],
-      `Class ${type} must define a fromString() OR fromJSON() static method.`,
-    );
-    this.toName.set(class_, [type, encoding]);
-    this.toClass.set(type, [class_, encoding]);
-  }
-
-  /**
-   * Does this type name have a registered class?
-   * @param type - The type name.
-   * @returns If there's a registered class.
-   */
-  isRegisteredClassName(type: string) {
-    return this.toClass.has(type);
-  }
-  /**
-   * Is this class object registered?
-   * @param obj - The class object.
-   * @returns If it is a registered class.
-   */
-  isRegisteredClass(obj: any) {
-    const name = obj.prototype.constructor.name;
-    return this.toName.has(obj) || this.isRegisteredClassName(name);
-  }
-  /**
-   * Convert a JSON-like object to a class object.
-   * @param jsonObj - An object encoding a class.
-   * @returns The class object.
-   */
-  toClassObj(jsonObj: JsonEncodedClass | StringEncodedClass): any {
-    const result = this.toClass.get(jsonObj.type);
-    assert(result, `Could not find type in lookup.`);
-
-    const [class_, encoding] = result;
-    if (encoding === 'string' && typeof jsonObj.data === 'string') {
-      return (class_ as StringIOClass)!.fromString!(jsonObj.data);
-    } else {
-      return (class_ as ObjIOClass)!.fromJSON!(jsonObj.data as object);
-    }
-  }
-  /**
-   * Convert a class object to a JSON object.
-   * @param classObj - A JSON encoding a class.
-   * @returns The class object.
-   */
-  toJsonObj(classObj: any): JsonEncodedClass | StringEncodedClass {
-    const { type, encoding } = this.lookupObject(classObj);
-    const data = encoding === 'string' ? classObj.toString() : classObj.toJSON();
-    return { type: type!, data };
-  }
-
-  /**
-   * Loads the corresponding type for this class based on constructor first and constructor name if not found.
-   * Constructor match works in the event of a minifier changing function names, and constructor name match
-   * works in the event of duplicated instances of node modules being loaded (see #1826).
-   * @param classObj - Object to lookup in the registered types.
-   * @returns Registered type name and encoding.
-   */
-  private lookupObject(classObj: any) {
-    const nameResult = this.toName.get(classObj.constructor);
-    if (nameResult) {
-      return { type: nameResult[0], encoding: nameResult[1] };
-    }
-    const classResult = this.toClass.get(classObj.constructor.name);
-    if (classResult) {
-      return { type: classObj.constructor.name, encoding: classResult[1] };
-    }
-    throw new Error(`Could not find class ${classObj.constructor.name} in lookup.`);
-  }
-}

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

@@ -1,148 +0,0 @@
-// comlink:
-//  Dev dependency just for the somewhat complex RemoteObject type
-//  This takes a {foo(): T} and makes {foo(): Promise<T>}
-//  while avoiding Promise of Promise.
-import { type RemoteObject } from 'comlink';
-import { format } from 'util';
-
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
-import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
-import { ClassConverter, type JsonClassConverterInput, type StringClassConverterInput } from '../class_converter.js';
-import { JsonStringify, convertFromJsonObj, convertToJsonObj } from '../convert.js';
-
-export { JsonStringify } from '../convert.js';
-
-const log = createDebugLogger('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).
- * @returns The parsed JSON response, or throws an error.
- */
-export async function defaultFetch(
-  host: string,
-  rpcMethod: string,
-  body: any,
-  useApiEndpoints: boolean,
-  noRetry = false,
-) {
-  log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
-  let resp: Response;
-  if (useApiEndpoints) {
-    resp = await fetch(`${host}/${rpcMethod}`, {
-      method: 'POST',
-      body: JsonStringify(body),
-      headers: { 'content-type': 'application/json' },
-    });
-  } else {
-    resp = await fetch(host, {
-      method: 'POST',
-      body: JsonStringify({ ...body, method: rpcMethod }),
-      headers: { 'content-type': 'application/json' },
-    });
-  }
-
-  let responseJson;
-  try {
-    responseJson = await resp.json();
-  } catch (err) {
-    if (!resp.ok) {
-      throw new Error(resp.statusText);
-    }
-    throw new Error(`Failed to parse body as JSON: ${resp.text()}`);
-  }
-  if (!resp.ok) {
-    const errorMessage = `(JSON-RPC PROPAGATED) (host ${host}) (method ${rpcMethod}) (code ${resp.status}) ${responseJson.error.message}`;
-    if (noRetry || (resp.status >= 400 && resp.status < 500)) {
-      throw new NoRetryError(errorMessage);
-    } else {
-      throw new Error(errorMessage);
-    }
-  }
-
-  return responseJson;
-}
-
-/**
- * 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.
- * @returns A fetch function.
- */
-export function makeFetch(retries: number[], noRetry: boolean, log?: DebugLogger) {
-  return async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) => {
-    return await retry(
-      () => defaultFetch(host, rpcMethod, body, useApiEndpoints, noRetry),
-      `JsonRpcClient request ${rpcMethod} to ${host}`,
-      makeBackoff(retries),
-      log,
-      false,
-    );
-  };
-}
-
-/**
- * Creates a Proxy object that delegates over RPC and satisfies RemoteObject<T>.
- * The server should have ran new JsonRpcServer().
- * @param host - The host URL.
- * @param stringClassMap - A map of class names to string representations.
- * @param objectClassMap - A map of class names to class constructors.
- * @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 createJsonRpcClient<T extends object>(
-  host: string,
-  stringClassMap: StringClassConverterInput,
-  objectClassMap: JsonClassConverterInput,
-  useApiEndpoints: boolean,
-  namespaceMethods?: string | false,
-  fetch = defaultFetch,
-) {
-  const classConverter = new ClassConverter(stringClassMap, objectClassMap);
-  let id = 0;
-  const request = async (method: string, params: any[]): Promise<any> => {
-    const body = {
-      jsonrpc: '2.0',
-      id: id++,
-      method,
-      params: params.map(param => convertToJsonObj(classConverter, param)),
-    };
-    log.debug(format(`JsonRpcClient.request`, method, '<-', params));
-    const res = await fetch(host, method, body, useApiEndpoints);
-    log.debug(format(`JsonRpcClient.result`, method, '->', res));
-    if (res.error) {
-      throw res.error;
-    }
-    if ([null, undefined, 'null', 'undefined'].includes(res.result)) {
-      return;
-    }
-    return convertFromJsonObj(classConverter, res.result);
-  };
-
-  // Intercept any RPC methods with a proxy
-  // This wraps 'request' with a method-call syntax wrapper
-  return new Proxy(
-    {},
-    {
-      get: (target, method: string) => {
-        let rpcMethod = method;
-        if (namespaceMethods) {
-          rpcMethod = `${namespaceMethods}_${method}`;
-        }
-        if (['then', 'catch'].includes(method)) {
-          return Reflect.get(target, method);
-        }
-        return (...params: any[]) => {
-          log.debug(format(`JsonRpcClient.constructor`, 'proxy', rpcMethod, '<-', params));
-          return request(rpcMethod, params);
-        };
-      },
-    },
-  ) as RemoteObject<T>;
-}

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

@@ -1,60 +0,0 @@
-import { format } from 'util';
-
-import { createDebugLogger } from '../../log/index.js';
-import { ClassConverter, type JsonClassConverterInput, type StringClassConverterInput } from '../class_converter.js';
-import { convertFromJsonObj, convertToJsonObj } from '../convert.js';
-import { assert, hasOwnProperty } from '../js_utils.js';
-
-const log = createDebugLogger('json-rpc:json_proxy');
-
-/**
- * A map of class names to class constructors.
- */
-export type ClassMaps = {
-  /** The String class map */
-  stringClassMap: StringClassConverterInput;
-  /** The object class map */
-  objectClassMap: JsonClassConverterInput;
-};
-
-/**
- * Handles conversion of objects over the write.
- * Delegates to a ClassConverter object.
- */
-export class JsonProxy {
-  classConverter: ClassConverter;
-  constructor(
-    private handler: object,
-    private stringClassMap: StringClassConverterInput,
-    private objectClassMap: JsonClassConverterInput,
-  ) {
-    this.classConverter = new ClassConverter(stringClassMap, objectClassMap);
-  }
-  /**
-   * Call an RPC method.
-   * @param methodName - The RPC method.
-   * @param jsonParams - The RPG parameters.
-   * @param skipConversion - Whether to skip conversion of the parameters.
-   * @returns The remote result.
-   */
-  public async call(methodName: string, jsonParams: any[] = [], skipConversion = false) {
-    log.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: ${methodName} params not an array: ${jsonParams}`);
-    // convert the params from json representation to classes
-    let convertedParams = jsonParams;
-    if (!skipConversion) {
-      convertedParams = jsonParams.map(param => convertFromJsonObj(this.classConverter, param));
-    }
-    log.debug(format('JsonProxy:call', methodName, '<-', convertedParams));
-    const rawRet = await (this.handler as any)[methodName](...convertedParams);
-    let ret = rawRet;
-    if (!skipConversion) {
-      ret = convertToJsonObj(this.classConverter, rawRet);
-    }
-    log.debug(format('JsonProxy:call', methodName, '->', ret));
-    return ret;
-  }
-}