@aztec/foundation 0.62.0 → 0.63.0

package/src/schemas/schemas.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+
+import { type AbiDecoded } from '../abi/decoder.js';
+import { EventSelector } from '../abi/event_selector.js';
+import { FunctionSelector } from '../abi/function_selector.js';
+import { NoteSelector } from '../abi/note_selector.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { Buffer32 } from '../buffer/buffer32.js';
+import { EthAddress } from '../eth-address/index.js';
+import { Signature } from '../eth-signature/eth_signature.js';
+import { Fq, Fr } from '../fields/fields.js';
+import { Point } from '../fields/point.js';
+import { hasHexPrefix, isHex, withoutHexPrefix } from '../string/index.js';
+import { type ZodFor } from './types.js';
+import { hexSchema, maybeStructuredStringSchemaFor } from './utils.js';
+
+const FrSchema = maybeStructuredStringSchemaFor('Fr', Fr, isHex);
+const FqSchema = maybeStructuredStringSchemaFor('Fq', Fq, isHex);
+
+/** Validation schemas for common types. Every schema must match its toJSON. */
+export const schemas = {
+  /** Accepts both a 0x string and a structured `{ type: EthAddress, value: '0x...' }` */
+  EthAddress: maybeStructuredStringSchemaFor('EthAddress', EthAddress, EthAddress.isAddress),
+
+  /** Accepts both a 0x string and a structured `{ type: AztecAddress, value: '0x...' }` */
+  AztecAddress: maybeStructuredStringSchemaFor('AztecAddress', AztecAddress, AztecAddress.isAddress),
+
+  /** Accepts both a 0x string and a structured type. */
+  FunctionSelector: maybeStructuredStringSchemaFor('FunctionSelector', FunctionSelector),
+
+  /** Accepts both a 0x string and a structured type. */
+  NoteSelector: maybeStructuredStringSchemaFor('NoteSelector', NoteSelector),
+
+  /** Accepts both a 0x string and a structured type. */
+  EventSelector: maybeStructuredStringSchemaFor('EventSelector', EventSelector),
+
+  /** Field element. Accepts a 0x prefixed hex string or a structured type. */
+  Fr: FrSchema,
+
+  /** Field element. Accepts a 0x prefixed hex string or a structured type. */
+  Fq: FqSchema,
+
+  /** Point. Serialized as 0x prefixed string or a type. */
+  Point: z
+    .object({
+      x: FrSchema,
+      y: FrSchema,
+      isInfinite: z.boolean().optional(),
+    })
+    .or(hexSchema)
+    .transform(value =>
+      typeof value === 'string' ? Point.fromString(value) : new Point(value.x, value.y, value.isInfinite ?? false),
+    ),
+
+  /** Accepts a 0x string */
+  Signature: z
+    .string()
+    .refine(hasHexPrefix, 'No hex prefix')
+    .refine(Signature.isValid0xString, 'Not a valid Ethereum signature')
+    .transform(Signature.from0xString),
+
+  /** Coerces any input to bigint */
+  BigInt: z.union([z.bigint(), z.number(), z.string()]).pipe(z.coerce.bigint()),
+
+  /** Coerces any input to integer number */
+  Integer: z.union([z.bigint(), z.number(), z.string()]).pipe(z.coerce.number().int()),
+
+  /** Coerces input to UInt32 */
+  UInt32: z.union([z.bigint(), z.number(), z.string()]).pipe(
+    z.coerce
+      .number()
+      .int()
+      .min(0)
+      .max(2 ** 32 - 1),
+  ),
+
+  /** Accepts a hex string as a Buffer32 type */
+  Buffer32: z.string().refine(isHex, 'Not a valid hex string').transform(Buffer32.fromString),
+
+  /** Accepts a base64 string or a structured `{ type: 'Buffer', data: [byte, byte...] }` as a buffer */
+  BufferB64: z.union([
+    z
+      .string()
+      .base64()
+      .transform(data => Buffer.from(data, 'base64')),
+    z
+      .object({
+        type: z.literal('Buffer'),
+        data: z.array(z.number().int().max(255)),
+      })
+      .transform(({ data }) => Buffer.from(data)),
+  ]),
+
+  /** Accepts a hex string with optional 0x prefix as a buffer */
+  BufferHex: z
+    .string()
+    .refine(isHex, 'Not a valid hex string')
+    .transform(withoutHexPrefix)
+    .transform(data => Buffer.from(data, 'hex')),
+
+  /** Hex string with an optional 0x prefix, which gets removed as part of the parsing */
+  HexString: hexSchema,
+};
+
+export const AbiDecodedSchema: ZodFor<AbiDecoded> = z.union([
+  schemas.BigInt,
+  z.boolean(),
+  schemas.AztecAddress,
+  z.array(z.lazy(() => AbiDecodedSchema)),
+  z.record(z.lazy(() => AbiDecodedSchema)),
+]);

package/src/schemas/types.ts

@@ -0,0 +1,3 @@
+import { type ZodType } from 'zod';
+
+export type ZodFor<T> = ZodType<T, any, any>;

package/src/schemas/utils.ts

@@ -0,0 +1,85 @@
+import {
+  OK,
+  type ParseInput,
+  type ParseReturnType,
+  ZodFirstPartyTypeKind,
+  ZodOptional,
+  ZodParsedType,
+  type ZodType,
+  type ZodTypeAny,
+  z,
+} from 'zod';
+
+import { isHex, withoutHexPrefix } from '../string/index.js';
+import { type ZodFor } from './types.js';
+
+export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
+
+export class ZodNullableOptional<T extends ZodTypeAny> extends ZodOptional<T> {
+  _isNullableOptional = true;
+
+  override _parse(input: ParseInput): ParseReturnType<this['_output']> {
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.undefined || parsedType === ZodParsedType.null) {
+      return OK(undefined);
+    }
+    return this._def.innerType._parse(input);
+  }
+
+  static override create<T extends ZodTypeAny>(type: T): ZodNullableOptional<T> {
+    return new ZodNullableOptional({
+      innerType: type,
+      typeName: ZodFirstPartyTypeKind.ZodOptional,
+    }) as any;
+  }
+}
+
+/**
+ * Declares a parameter as optional. Use this over z.optional in order to accept nulls as undefineds.
+ * This is required as JSON does not have an undefined type, and null is used to represent it, so we
+ * need to convert nulls to undefineds as we parse.
+ */
+export function optional<T extends ZodTypeAny>(schema: T) {
+  return ZodNullableOptional.create(schema);
+}
+
+/**
+ * Creates a schema that accepts a hex string and uses it to hydrate an instance.
+ * @param klazz - Class that implements either fromString or fromBuffer.
+ * @returns A schema for the class.
+ */
+export function hexSchemaFor<TClass extends { fromString(str: string): any } | { fromBuffer(buf: Buffer): any }>(
+  klazz: TClass,
+): ZodType<
+  TClass extends { fromString(str: string): infer TInstance } | { fromBuffer(buf: Buffer): infer TInstance }
+    ? TInstance
+    : never,
+  any,
+  string
+> {
+  return 'fromString' in klazz
+    ? hexSchema.transform(klazz.fromString.bind(klazz))
+    : hexSchema.transform(str => Buffer.from(str, 'hex')).transform(klazz.fromBuffer.bind(klazz));
+}
+
+// TODO(palla/schemas): Delete this class once all serialization of the type { type: string, value: string } are removed.
+export function maybeStructuredStringSchemaFor<TClass extends { fromString(str: string): any }>(
+  name: string,
+  klazz: TClass,
+  refinement?: (input: string) => boolean,
+): ZodFor<TClass extends { fromString(str: string): infer TInstance } ? TInstance : never> {
+  const stringSchema = refinement ? z.string().refine(refinement, `Not a valid ${name}`) : z.string();
+  return z
+    .union([stringSchema, z.object({ type: z.literal(name), value: stringSchema })])
+    .transform(input => klazz.fromString(typeof input === 'string' ? input : input.value));
+}
+
+/** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */
+export function mapSchema<TKey, TValue>(key: ZodFor<TKey>, value: ZodFor<TValue>): ZodFor<Map<TKey, TValue>> {
+  return z.array(z.tuple([key, value])).transform(entries => new Map(entries));
+}
+
+/** Creates a schema for a js Set type that matches the serialization used in jsonStringify. */
+export function setSchema<T>(value: ZodFor<T>): ZodFor<Set<T>> {
+  return z.array(value).transform(entries => new Set(entries));
+}

package/src/string/index.ts

@@ -0,0 +1,15 @@
+export function hasHexPrefix(str: string): str is `0x${string}` {
+  return str.startsWith('0x');
+}
+
+export function withoutHexPrefix(str: string): string {
+  return hasHexPrefix(str) ? str.slice(2) : str;
+}
+
+export function isHex(str: string): boolean {
+  return /^(0x)?[0-9a-fA-F]*$/.test(str);
+}
+
+export function hexToBuffer(str: string): Buffer {
+  return Buffer.from(withoutHexPrefix(str), 'hex');
+}

package/src/types/index.ts

@@ -20,3 +20,6 @@ export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
 export function unfreeze<T>(obj: T): Writeable<T> {
   return obj as Writeable<T>;
 }
+
+/** Maybe exists, maybe not. */
+export type Maybe<T extends object> = T | unknown;

package/src/validation/index.ts

@@ -5,3 +5,14 @@ export function required<T>(value: T | undefined, errMsg?: string): T {
   }
   return value;
 }
+
+/**
+ * Helper function to assert a condition is truthy
+ * @param x - A boolean condition to assert.
+ * @param err - Error message to throw if x isn't met.
+ */
+export function assert(x: any, err: string): asserts x {
+  if (!x) {
+    throw new Error(err);
+  }
+}

package/dest/json-rpc/class_converter.d.ts

@@ -1,144 +0,0 @@
-/**
- * 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;
-    /**
-     * 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;
-    /**
-     * 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 declare class ClassConverter {
-    private toClass;
-    private toName;
-    /**
-     * 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);
-    /**
-     * 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): void;
-    /**
-     * Does this type name have a registered class?
-     * @param type - The type name.
-     * @returns If there's a registered class.
-     */
-    isRegisteredClassName(type: string): boolean;
-    /**
-     * Is this class object registered?
-     * @param obj - The class object.
-     * @returns If it is a registered class.
-     */
-    isRegisteredClass(obj: any): boolean;
-    /**
-     * 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;
-    /**
-     * Convert a class object to a JSON object.
-     * @param classObj - A JSON encoding a class.
-     * @returns The class object.
-     */
-    toJsonObj(classObj: any): JsonEncodedClass | StringEncodedClass;
-    /**
-     * 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;
-}
-export {};
-//# sourceMappingURL=class_converter.d.ts.map

package/dest/json-rpc/class_converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class_converter.d.ts","sourceRoot":"","sources":["../../src/json-rpc/class_converter.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,UAAU,aAAa;IACrB,KAAK,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAIxB;;OAEG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;CAClC;AAED;;;;;;;;;;;;;GAaG;AACH,UAAU,UAAU;IAClB,KAAK,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAIxB;;OAEG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;CAChC;AAED;;GAEG;AACH,KAAK,OAAO,GAAG,UAAU,GAAG,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AACD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEhD;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,MAAM,CAA+C;IAE7D;;;;OAIG;gBACS,cAAc,CAAC,EAAE,yBAAyB,EAAE,cAAc,CAAC,EAAE,uBAAuB;IAahG;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa;IAc/D;;;;OAIG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM;IAGlC;;;;OAIG;IACH,iBAAiB,CAAC,GAAG,EAAE,GAAG;IAI1B;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,kBAAkB,GAAG,GAAG;IAW/D;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,GAAG,GAAG,gBAAgB,GAAG,kBAAkB;IAM/D;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;CAWrB"}

package/dest/json-rpc/class_converter.js

@@ -1,102 +0,0 @@
-import { assert } from './js_utils.js';
-/**
- * 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 {
-    /**
-     * 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, objectClassMap) {
-        this.toClass = new Map();
-        this.toName = new Map();
-        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, class_, encoding) {
-        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_['fromString'] || class_['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) {
-        return this.toClass.has(type);
-    }
-    /**
-     * Is this class object registered?
-     * @param obj - The class object.
-     * @returns If it is a registered class.
-     */
-    isRegisteredClass(obj) {
-        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) {
-        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_.fromString(jsonObj.data);
-        }
-        else {
-            return class_.fromJSON(jsonObj.data);
-        }
-    }
-    /**
-     * Convert a class object to a JSON object.
-     * @param classObj - A JSON encoding a class.
-     * @returns The class object.
-     */
-    toJsonObj(classObj) {
-        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.
-     */
-    lookupObject(classObj) {
-        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.`);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,35 +0,0 @@
-import { type RemoteObject } from 'comlink';
-import { type DebugLogger } from '../../log/index.js';
-import { type JsonClassConverterInput, type StringClassConverterInput } from '../class_converter.js';
-export { JsonStringify } from '../convert.js';
-/**
- * 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 declare function defaultFetch(host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, noRetry?: boolean): Promise<any>;
-/**
- * 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 declare function makeFetch(retries: number[], noRetry: boolean, log?: DebugLogger): (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) => Promise<any>;
-/**
- * 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 declare function createJsonRpcClient<T extends object>(host: string, stringClassMap: StringClassConverterInput, objectClassMap: JsonClassConverterInput, useApiEndpoints: boolean, namespaceMethods?: string | false, fetch?: typeof defaultFetch): RemoteObject<T>;
-//# sourceMappingURL=json_rpc_client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"json_rpc_client.d.ts","sourceRoot":"","sources":["../../../src/json-rpc/client/json_rpc_client.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,oBAAoB,CAAC;AAEzE,OAAO,EAAkB,KAAK,uBAAuB,EAAE,KAAK,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAGrH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG9C;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,GAAG,EACT,eAAe,EAAE,OAAO,EACxB,OAAO,UAAQ,gBAqChB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,WAAW,UAC1D,MAAM,aAAa,MAAM,QAAQ,GAAG,mBAAmB,OAAO,kBASnF;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAClD,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,yBAAyB,EACzC,cAAc,EAAE,uBAAuB,EACvC,eAAe,EAAE,OAAO,EACxB,gBAAgB,CAAC,EAAE,MAAM,GAAG,KAAK,EACjC,KAAK,sBAAe,mBA2CrB"}

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

@@ -1,117 +0,0 @@
-import { format } from 'util';
-import { createDebugLogger } from '../../log/index.js';
-import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
-import { ClassConverter } 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, rpcMethod, body, useApiEndpoints, noRetry = false) {
-    log.debug(format(`JsonRpcClient.fetch`, host, rpcMethod, '->', body));
-    let resp;
-    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, noRetry, log) {
-    return async (host, rpcMethod, body, useApiEndpoints) => {
-        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(host, stringClassMap, objectClassMap, useApiEndpoints, namespaceMethods, fetch = defaultFetch) {
-    const classConverter = new ClassConverter(stringClassMap, objectClassMap);
-    let id = 0;
-    const request = async (method, params) => {
-        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) => {
-            let rpcMethod = method;
-            if (namespaceMethods) {
-                rpcMethod = `${namespaceMethods}_${method}`;
-            }
-            if (['then', 'catch'].includes(method)) {
-                return Reflect.get(target, method);
-            }
-            return (...params) => {
-                log.debug(format(`JsonRpcClient.constructor`, 'proxy', rpcMethod, '<-', params));
-                return request(rpcMethod, params);
-            };
-        },
-    });
-}
-//# sourceMappingURL=data:application/json;base64,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