@metamask/utils 6.2.0 → 7.1.0

package/dist/cjs/json.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    UnsafeJsonStruct: function() {
+        return UnsafeJsonStruct;
+    },
+    JsonStruct: function() {
+        return JsonStruct;
+    },
+    isValidJson: function() {
+        return isValidJson;
+    },
+    getSafeJson: function() {
+        return getSafeJson;
+    },
+    getJsonSize: function() {
+        return getJsonSize;
+    },
+    jsonrpc2: function() {
+        return jsonrpc2;
+    },
+    JsonRpcVersionStruct: function() {
+        return JsonRpcVersionStruct;
+    },
+    JsonRpcIdStruct: function() {
+        return JsonRpcIdStruct;
+    },
+    JsonRpcErrorStruct: function() {
+        return JsonRpcErrorStruct;
+    },
+    JsonRpcParamsStruct: function() {
+        return JsonRpcParamsStruct;
+    },
+    JsonRpcRequestStruct: function() {
+        return JsonRpcRequestStruct;
+    },
+    JsonRpcNotificationStruct: function() {
+        return JsonRpcNotificationStruct;
+    },
+    isJsonRpcNotification: function() {
+        return isJsonRpcNotification;
+    },
+    assertIsJsonRpcNotification: function() {
+        return assertIsJsonRpcNotification;
+    },
+    isJsonRpcRequest: function() {
+        return isJsonRpcRequest;
+    },
+    assertIsJsonRpcRequest: function() {
+        return assertIsJsonRpcRequest;
+    },
+    PendingJsonRpcResponseStruct: function() {
+        return PendingJsonRpcResponseStruct;
+    },
+    JsonRpcSuccessStruct: function() {
+        return JsonRpcSuccessStruct;
+    },
+    JsonRpcFailureStruct: function() {
+        return JsonRpcFailureStruct;
+    },
+    JsonRpcResponseStruct: function() {
+        return JsonRpcResponseStruct;
+    },
+    isPendingJsonRpcResponse: function() {
+        return isPendingJsonRpcResponse;
+    },
+    assertIsPendingJsonRpcResponse: function() {
+        return assertIsPendingJsonRpcResponse;
+    },
+    isJsonRpcResponse: function() {
+        return isJsonRpcResponse;
+    },
+    assertIsJsonRpcResponse: function() {
+        return assertIsJsonRpcResponse;
+    },
+    isJsonRpcSuccess: function() {
+        return isJsonRpcSuccess;
+    },
+    assertIsJsonRpcSuccess: function() {
+        return assertIsJsonRpcSuccess;
+    },
+    isJsonRpcFailure: function() {
+        return isJsonRpcFailure;
+    },
+    assertIsJsonRpcFailure: function() {
+        return assertIsJsonRpcFailure;
+    },
+    isJsonRpcError: function() {
+        return isJsonRpcError;
+    },
+    assertIsJsonRpcError: function() {
+        return assertIsJsonRpcError;
+    },
+    getJsonRpcIdValidator: function() {
+        return getJsonRpcIdValidator;
+    }
+});
+const _superstruct = require("superstruct");
+const _assert = require("./assert");
+/**
+ * A struct to check if the given value is finite number. Superstruct's
+ * `number()` struct does not check if the value is finite.
+ *
+ * @returns A struct to check if the given value is finite number.
+ */ const finiteNumber = ()=>(0, _superstruct.define)('finite number', (value)=>{
+        return (0, _superstruct.is)(value, (0, _superstruct.number)()) && Number.isFinite(value);
+    });
+const UnsafeJsonStruct = (0, _superstruct.union)([
+    (0, _superstruct.literal)(null),
+    (0, _superstruct.boolean)(),
+    finiteNumber(),
+    (0, _superstruct.string)(),
+    (0, _superstruct.array)((0, _superstruct.lazy)(()=>UnsafeJsonStruct)),
+    (0, _superstruct.record)((0, _superstruct.string)(), (0, _superstruct.lazy)(()=>UnsafeJsonStruct))
+]);
+const JsonStruct = (0, _superstruct.coerce)(UnsafeJsonStruct, (0, _superstruct.any)(), (value)=>{
+    (0, _assert.assertStruct)(value, UnsafeJsonStruct);
+    return JSON.parse(JSON.stringify(value, (propKey, propValue)=>{
+        // Strip __proto__ and constructor properties to prevent prototype pollution.
+        if (propKey === '__proto__' || propKey === 'constructor') {
+            return undefined;
+        }
+        return propValue;
+    }));
+});
+function isValidJson(value) {
+    try {
+        getSafeJson(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function getSafeJson(value) {
+    return (0, _superstruct.create)(value, JsonStruct);
+}
+function getJsonSize(value) {
+    (0, _assert.assertStruct)(value, JsonStruct, 'Invalid JSON value');
+    const json = JSON.stringify(value);
+    return new TextEncoder().encode(json).byteLength;
+}
+const jsonrpc2 = '2.0';
+const JsonRpcVersionStruct = (0, _superstruct.literal)(jsonrpc2);
+const JsonRpcIdStruct = (0, _superstruct.nullable)((0, _superstruct.union)([
+    (0, _superstruct.number)(),
+    (0, _superstruct.string)()
+]));
+const JsonRpcErrorStruct = (0, _superstruct.object)({
+    code: (0, _superstruct.integer)(),
+    message: (0, _superstruct.string)(),
+    data: (0, _superstruct.optional)(JsonStruct),
+    stack: (0, _superstruct.optional)((0, _superstruct.string)())
+});
+const JsonRpcParamsStruct = (0, _superstruct.optional)((0, _superstruct.union)([
+    (0, _superstruct.record)((0, _superstruct.string)(), JsonStruct),
+    (0, _superstruct.array)(JsonStruct)
+]));
+const JsonRpcRequestStruct = (0, _superstruct.object)({
+    id: JsonRpcIdStruct,
+    jsonrpc: JsonRpcVersionStruct,
+    method: (0, _superstruct.string)(),
+    params: JsonRpcParamsStruct
+});
+const JsonRpcNotificationStruct = (0, _superstruct.omit)(JsonRpcRequestStruct, [
+    'id'
+]);
+function isJsonRpcNotification(value) {
+    return (0, _superstruct.is)(value, JsonRpcNotificationStruct);
+}
+function assertIsJsonRpcNotification(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcNotificationStruct, 'Invalid JSON-RPC notification', ErrorWrapper);
+}
+function isJsonRpcRequest(value) {
+    return (0, _superstruct.is)(value, JsonRpcRequestStruct);
+}
+function assertIsJsonRpcRequest(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcRequestStruct, 'Invalid JSON-RPC request', ErrorWrapper);
+}
+const PendingJsonRpcResponseStruct = (0, _superstruct.object)({
+    id: JsonRpcIdStruct,
+    jsonrpc: JsonRpcVersionStruct,
+    result: (0, _superstruct.optional)((0, _superstruct.unknown)()),
+    error: (0, _superstruct.optional)(JsonRpcErrorStruct)
+});
+const JsonRpcSuccessStruct = (0, _superstruct.object)({
+    id: JsonRpcIdStruct,
+    jsonrpc: JsonRpcVersionStruct,
+    result: JsonStruct
+});
+const JsonRpcFailureStruct = (0, _superstruct.object)({
+    id: JsonRpcIdStruct,
+    jsonrpc: JsonRpcVersionStruct,
+    error: JsonRpcErrorStruct
+});
+const JsonRpcResponseStruct = (0, _superstruct.union)([
+    JsonRpcSuccessStruct,
+    JsonRpcFailureStruct
+]);
+function isPendingJsonRpcResponse(response) {
+    return (0, _superstruct.is)(response, PendingJsonRpcResponseStruct);
+}
+function assertIsPendingJsonRpcResponse(response, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(response, PendingJsonRpcResponseStruct, 'Invalid pending JSON-RPC response', ErrorWrapper);
+}
+function isJsonRpcResponse(response) {
+    return (0, _superstruct.is)(response, JsonRpcResponseStruct);
+}
+function assertIsJsonRpcResponse(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcResponseStruct, 'Invalid JSON-RPC response', ErrorWrapper);
+}
+function isJsonRpcSuccess(value) {
+    return (0, _superstruct.is)(value, JsonRpcSuccessStruct);
+}
+function assertIsJsonRpcSuccess(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcSuccessStruct, 'Invalid JSON-RPC success response', ErrorWrapper);
+}
+function isJsonRpcFailure(value) {
+    return (0, _superstruct.is)(value, JsonRpcFailureStruct);
+}
+function assertIsJsonRpcFailure(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcFailureStruct, 'Invalid JSON-RPC failure response', ErrorWrapper);
+}
+function isJsonRpcError(value) {
+    return (0, _superstruct.is)(value, JsonRpcErrorStruct);
+}
+function assertIsJsonRpcError(value, // eslint-disable-next-line @typescript-eslint/naming-convention
+ErrorWrapper) {
+    (0, _assert.assertStruct)(value, JsonRpcErrorStruct, 'Invalid JSON-RPC error', ErrorWrapper);
+}
+function getJsonRpcIdValidator(options) {
+    const { permitEmptyString, permitFractions, permitNull } = {
+        permitEmptyString: true,
+        permitFractions: false,
+        permitNull: true,
+        ...options
+    };
+    /**
+   * Type guard for {@link JsonRpcId}.
+   *
+   * @param id - The JSON-RPC ID value to check.
+   * @returns Whether the given ID is valid per the options given to the
+   * factory.
+   */ const isValidJsonRpcId = (id)=>{
+        return Boolean(typeof id === 'number' && (permitFractions || Number.isInteger(id)) || typeof id === 'string' && (permitEmptyString || id.length > 0) || permitNull && id === null);
+    };
+    return isValidJsonRpcId;
+}
+
+//# sourceMappingURL=json.js.map

package/dist/cjs/json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/json.ts"],"sourcesContent":["import type { Infer, Struct } from 'superstruct';\nimport {\n  any,\n  array,\n  boolean,\n  coerce,\n  create,\n  define,\n  integer,\n  is,\n  lazy,\n  literal,\n  nullable,\n  number,\n  object,\n  omit,\n  optional,\n  record,\n  string,\n  union,\n  unknown,\n} from 'superstruct';\n\nimport type { AssertionErrorConstructor } from './assert';\nimport { assertStruct } from './assert';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * A struct to check if the given value is finite number. Superstruct's\n * `number()` struct does not check if the value is finite.\n *\n * @returns A struct to check if the given value is finite number.\n */\nconst finiteNumber = () =>\n  define<number>('finite number', (value) => {\n    return is(value, number()) && Number.isFinite(value);\n  });\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * Note that this struct is unsafe. For safe validation, use {@link JsonStruct}.\n */\n// We cannot infer the type of the struct, because it is recursive.\nexport const UnsafeJsonStruct: Struct<Json> = union([\n  literal(null),\n  boolean(),\n  finiteNumber(),\n  string(),\n  array(lazy(() => UnsafeJsonStruct)),\n  record(\n    string(),\n    lazy(() => UnsafeJsonStruct),\n  ),\n]);\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * This struct sanitizes the value before validating it, so that it is safe to\n * use with untrusted input.\n */\nexport const JsonStruct = coerce(UnsafeJsonStruct, any(), (value) => {\n  assertStruct(value, UnsafeJsonStruct);\n  return JSON.parse(\n    JSON.stringify(value, (propKey, propValue) => {\n      // Strip __proto__ and constructor properties to prevent prototype pollution.\n      if (propKey === '__proto__' || propKey === 'constructor') {\n        return undefined;\n      }\n      return propValue;\n    }),\n  );\n});\n\n/**\n * Check if the given value is a valid {@link Json} value, i.e., a value that is\n * serializable to JSON.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link Json} value.\n */\nexport function isValidJson(value: unknown): value is Json {\n  try {\n    getSafeJson(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate and return sanitized JSON.\n *\n * Note:\n * This function uses sanitized JsonStruct for validation\n * that applies stringify and then parse of a value provided\n * to ensure that there are no getters which can have side effects\n * that can cause security issues.\n *\n * @param value - JSON structure to be processed.\n * @returns Sanitized JSON structure.\n */\nexport function getSafeJson<Type extends Json = Json>(value: unknown): Type {\n  return create(value, JsonStruct) as Type;\n}\n\n/**\n * Get the size of a JSON value in bytes. This also validates the value.\n *\n * @param value - The JSON value to get the size of.\n * @returns The size of the JSON value in bytes.\n */\nexport function getJsonSize(value: unknown): number {\n  assertStruct(value, JsonStruct, 'Invalid JSON value');\n\n  const json = JSON.stringify(value);\n  return new TextEncoder().encode(json).byteLength;\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\nexport const JsonRpcVersionStruct = literal(jsonrpc2);\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\nexport const JsonRpcIdStruct = nullable(union([number(), string()]));\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = Infer<typeof JsonRpcIdStruct>;\n\nexport const JsonRpcErrorStruct = object({\n  code: integer(),\n  message: string(),\n  data: optional(JsonStruct),\n  stack: optional(string()),\n});\n\n/**\n * Mark a certain key of a type as optional.\n */\nexport type OptionalField<\n  Type extends Record<string, unknown>,\n  Key extends keyof Type,\n> = Omit<Type, Key> & Partial<Pick<Type, Key>>;\n\n/**\n * A JSON-RPC error object.\n *\n * Note that TypeScript infers `unknown | undefined` as `unknown`, meaning that\n * the `data` field is not optional. To make it optional, we use the\n * `OptionalField` helper, to explicitly make it optional.\n */\nexport type JsonRpcError = OptionalField<\n  Infer<typeof JsonRpcErrorStruct>,\n  'data'\n>;\n\nexport const JsonRpcParamsStruct = optional(\n  union([record(string(), JsonStruct), array(JsonStruct)]),\n);\nexport type JsonRpcParams = Infer<typeof JsonRpcParamsStruct>;\n\nexport const JsonRpcRequestStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: JsonRpcParamsStruct,\n});\n\nexport type InferWithParams<\n  Type extends Struct<any>,\n  Params extends JsonRpcParams,\n> = Omit<Infer<Type>, 'params'> &\n  (keyof Params extends undefined\n    ? {\n        params?: Params;\n      }\n    : {\n        params: Params;\n      });\n\n/**\n * A JSON-RPC request object.\n */\nexport type JsonRpcRequest<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcRequestStruct, Params>;\n\nexport const JsonRpcNotificationStruct = omit(JsonRpcRequestStruct, ['id']);\n\n/**\n * A JSON-RPC notification object.\n */\nexport type JsonRpcNotification<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcNotificationStruct, Params>;\n\n/**\n * Check if the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcNotification}\n * object.\n */\nexport function isJsonRpcNotification(\n  value: unknown,\n): value is JsonRpcNotification {\n  return is(value, JsonRpcNotificationStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcNotification} object.\n */\nexport function assertIsJsonRpcNotification(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcNotification {\n  assertStruct(\n    value,\n    JsonRpcNotificationStruct,\n    'Invalid JSON-RPC notification',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcRequest} object.\n */\nexport function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {\n  return is(value, JsonRpcRequestStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The JSON-RPC request or notification to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcRequest} object.\n */\nexport function assertIsJsonRpcRequest(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcRequest {\n  assertStruct(\n    value,\n    JsonRpcRequestStruct,\n    'Invalid JSON-RPC request',\n    ErrorWrapper,\n  );\n}\n\nexport const PendingJsonRpcResponseStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: optional(unknown()),\n  error: optional(JsonRpcErrorStruct),\n});\n\n/**\n * A JSON-RPC response object that has not yet been resolved.\n */\nexport type PendingJsonRpcResponse<Result extends Json> = Omit<\n  Infer<typeof PendingJsonRpcResponseStruct>,\n  'result'\n> & {\n  result?: Result;\n};\n\nexport const JsonRpcSuccessStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: JsonStruct,\n});\n\n/**\n * A successful JSON-RPC response object.\n */\nexport type JsonRpcSuccess<Result extends Json> = Omit<\n  Infer<typeof JsonRpcSuccessStruct>,\n  'result'\n> & {\n  result: Result;\n};\n\nexport const JsonRpcFailureStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  error: JsonRpcErrorStruct as Struct<JsonRpcError>,\n});\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = Infer<typeof JsonRpcFailureStruct>;\n\nexport const JsonRpcResponseStruct = union([\n  JsonRpcSuccessStruct,\n  JsonRpcFailureStruct,\n]);\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result extends Json> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * Type guard to check whether specified JSON-RPC response is a\n * {@link PendingJsonRpcResponse}.\n *\n * @param response - The JSON-RPC response to check.\n * @returns Whether the specified JSON-RPC response is pending.\n */\nexport function isPendingJsonRpcResponse(\n  response: unknown,\n): response is PendingJsonRpcResponse<Json> {\n  return is(response, PendingJsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link PendingJsonRpcResponse} object.\n *\n * @param response - The JSON-RPC response to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link PendingJsonRpcResponse}\n * object.\n */\nexport function assertIsPendingJsonRpcResponse(\n  response: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts response is PendingJsonRpcResponse<Json> {\n  assertStruct(\n    response,\n    PendingJsonRpcResponseStruct,\n    'Invalid pending JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Type guard to check if a value is a {@link JsonRpcResponse}.\n *\n * @param response - The object to check.\n * @returns Whether the object is a JsonRpcResponse.\n */\nexport function isJsonRpcResponse(\n  response: unknown,\n): response is JsonRpcResponse<Json> {\n  return is(response, JsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcResponse} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcResponse} object.\n */\nexport function assertIsJsonRpcResponse(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcResponse<Json> {\n  assertStruct(\n    value,\n    JsonRpcResponseStruct,\n    'Invalid JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcSuccess} object.\n */\nexport function isJsonRpcSuccess(\n  value: unknown,\n): value is JsonRpcSuccess<Json> {\n  return is(value, JsonRpcSuccessStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcSuccess} object.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcSuccess<Json> {\n  assertStruct(\n    value,\n    JsonRpcSuccessStruct,\n    'Invalid JSON-RPC success response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcFailure} object.\n */\nexport function isJsonRpcFailure(value: unknown): value is JsonRpcFailure {\n  return is(value, JsonRpcFailureStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcFailure} object.\n */\nexport function assertIsJsonRpcFailure(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcFailure {\n  assertStruct(\n    value,\n    JsonRpcFailureStruct,\n    'Invalid JSON-RPC failure response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcError} object.\n */\nexport function isJsonRpcError(value: unknown): value is JsonRpcError {\n  return is(value, JsonRpcErrorStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcError} object.\n */\nexport function assertIsJsonRpcError(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcError {\n  assertStruct(\n    value,\n    JsonRpcErrorStruct,\n    'Invalid JSON-RPC error',\n    ErrorWrapper,\n  );\n}\n\ntype JsonRpcValidatorOptions = {\n  permitEmptyString?: boolean;\n  permitFractions?: boolean;\n  permitNull?: boolean;\n};\n\n/**\n * Gets a function for validating JSON-RPC request / response `id` values.\n *\n * By manipulating the options of this factory, you can control the behavior\n * of the resulting validator for some edge cases. This is useful because e.g.\n * `null` should sometimes but not always be permitted.\n *\n * Note that the empty string (`''`) is always permitted by the JSON-RPC\n * specification, but that kind of sucks and you may want to forbid it in some\n * instances anyway.\n *\n * For more details, see the\n * [JSON-RPC Specification](https://www.jsonrpc.org/specification).\n *\n * @param options - An options object.\n * @param options.permitEmptyString - Whether the empty string (i.e. `''`)\n * should be treated as a valid ID. Default: `true`\n * @param options.permitFractions - Whether fractional numbers (e.g. `1.2`)\n * should be treated as valid IDs. Default: `false`\n * @param options.permitNull - Whether `null` should be treated as a valid ID.\n * Default: `true`\n * @returns The JSON-RPC ID validator function.\n */\nexport function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions) {\n  const { permitEmptyString, permitFractions, permitNull } = {\n    permitEmptyString: true,\n    permitFractions: false,\n    permitNull: true,\n    ...options,\n  };\n\n  /**\n   * Type guard for {@link JsonRpcId}.\n   *\n   * @param id - The JSON-RPC ID value to check.\n   * @returns Whether the given ID is valid per the options given to the\n   * factory.\n   */\n  const isValidJsonRpcId = (id: unknown): id is JsonRpcId => {\n    return Boolean(\n      (typeof id === 'number' && (permitFractions || Number.isInteger(id))) ||\n        (typeof id === 'string' && (permitEmptyString || id.length > 0)) ||\n        (permitNull && id === null),\n    );\n  };\n\n  return isValidJsonRpcId;\n}\n"],"names":["UnsafeJsonStruct","JsonStruct","isValidJson","getSafeJson","getJsonSize","jsonrpc2","JsonRpcVersionStruct","JsonRpcIdStruct","JsonRpcErrorStruct","JsonRpcParamsStruct","JsonRpcRequestStruct","JsonRpcNotificationStruct","isJsonRpcNotification","assertIsJsonRpcNotification","isJsonRpcRequest","assertIsJsonRpcRequest","PendingJsonRpcResponseStruct","JsonRpcSuccessStruct","JsonRpcFailureStruct","JsonRpcResponseStruct","isPendingJsonRpcResponse","assertIsPendingJsonRpcResponse","isJsonRpcResponse","assertIsJsonRpcResponse","isJsonRpcSuccess","assertIsJsonRpcSuccess","isJsonRpcFailure","assertIsJsonRpcFailure","isJsonRpcError","assertIsJsonRpcError","getJsonRpcIdValidator","finiteNumber","define","value","is","number","Number","isFinite","union","literal","boolean","string","array","lazy","record","coerce","any","assertStruct","JSON","parse","stringify","propKey","propValue","undefined","create","json","TextEncoder","encode","byteLength","nullable","object","code","integer","message","data","optional","stack","id","jsonrpc","method","params","omit","ErrorWrapper","result","unknown","error","response","options","permitEmptyString","permitFractions","permitNull","isValidJsonRpcId","Boolean","isInteger","length"],"mappings":"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"}

package/dist/cjs/keyring.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=keyring.js.map

package/dist/cjs/keyring.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/keyring.ts"],"names":[],"mappings":""}

package/dist/cjs/logging.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createProjectLogger: function() {
+        return createProjectLogger;
+    },
+    createModuleLogger: function() {
+        return createModuleLogger;
+    }
+});
+const _debug = /*#__PURE__*/ _interop_require_default(require("debug"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const globalLogger = (0, _debug.default)('metamask');
+function createProjectLogger(projectName) {
+    return globalLogger.extend(projectName);
+}
+function createModuleLogger(projectLogger, moduleName) {
+    return projectLogger.extend(moduleName);
+}
+
+//# sourceMappingURL=logging.js.map

package/dist/cjs/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/logging.ts"],"sourcesContent":["import type { Debugger } from 'debug';\nimport debug from 'debug';\n\nconst globalLogger = debug('metamask');\n\n/**\n * Creates a logger via the `debug` library whose log messages will be tagged\n * using the name of your project. By default, such messages will be\n * suppressed, but you can reveal them by setting the `DEBUG` environment\n * variable to `metamask:<projectName>`. You can also set this variable to\n * `metamask:*` if you want to see log messages from all MetaMask projects that\n * are also using this function to create their loggers.\n *\n * @param projectName - The name of your project. This should be the name of\n * your NPM package if you're developing one.\n * @returns An instance of `debug`.\n */\nexport function createProjectLogger(projectName: string): Debugger {\n  return globalLogger.extend(projectName);\n}\n\n/**\n * Creates a logger via the `debug` library which is derived from the logger for\n * the whole project whose log messages will be tagged using the name of your\n * module. By default, such messages will be suppressed, but you can reveal them\n * by setting the `DEBUG` environment variable to\n * `metamask:<projectName>:<moduleName>`. You can also set this variable to\n * `metamask:<projectName>:*` if you want to see log messages from the project,\n * or `metamask:*` if you want to see log messages from all MetaMask projects.\n *\n * @param projectLogger - The logger created via {@link createProjectLogger}.\n * @param moduleName - The name of your module. You could use the name of the\n * file where you're using this logger or some other name.\n * @returns An instance of `debug`.\n */\nexport function createModuleLogger(\n  projectLogger: Debugger,\n  moduleName: string,\n): Debugger {\n  return projectLogger.extend(moduleName);\n}\n"],"names":["createProjectLogger","createModuleLogger","globalLogger","debug","projectName","extend","projectLogger","moduleName"],"mappings":";;;;;;;;;;;IAiBgBA,mBAAmB;eAAnBA;;IAkBAC,kBAAkB;eAAlBA;;;8DAlCE;;;;;;AAElB,MAAMC,eAAeC,IAAAA,cAAK,EAAC;AAcpB,SAASH,oBAAoBI,WAAmB;IACrD,OAAOF,aAAaG,MAAM,CAACD;AAC7B;AAgBO,SAASH,mBACdK,aAAuB,EACvBC,UAAkB;IAElB,OAAOD,cAAcD,MAAM,CAACE;AAC9B"}

package/dist/cjs/misc.js

@@ -0,0 +1,111 @@
+//
+// Types
+//
+/**
+ * Makes every specified property of the specified object type mutable.
+ *
+ * @template ObjectValue - The object whose readonly properties to make mutable.
+ * @template TargetKey - The property key(s) to make mutable.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    JsonSize: function() {
+        return JsonSize;
+    },
+    isNonEmptyArray: function() {
+        return isNonEmptyArray;
+    },
+    isNullOrUndefined: function() {
+        return isNullOrUndefined;
+    },
+    isObject: function() {
+        return isObject;
+    },
+    hasProperty: function() {
+        return hasProperty;
+    },
+    getKnownPropertyNames: function() {
+        return getKnownPropertyNames;
+    },
+    ESCAPE_CHARACTERS_REGEXP: function() {
+        return ESCAPE_CHARACTERS_REGEXP;
+    },
+    isPlainObject: function() {
+        return isPlainObject;
+    },
+    isASCII: function() {
+        return isASCII;
+    },
+    calculateStringSize: function() {
+        return calculateStringSize;
+    },
+    calculateNumberSize: function() {
+        return calculateNumberSize;
+    }
+});
+function isNonEmptyArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+const hasProperty = (objectToCheck, name)=>Object.hasOwnProperty.call(objectToCheck, name);
+function getKnownPropertyNames(object) {
+    return Object.getOwnPropertyNames(object);
+}
+var JsonSize;
+(function(JsonSize) {
+    JsonSize[JsonSize["Null"] = 4] = "Null";
+    JsonSize[JsonSize["Comma"] = 1] = "Comma";
+    JsonSize[JsonSize["Wrapper"] = 1] = "Wrapper";
+    JsonSize[JsonSize["True"] = 4] = "True";
+    JsonSize[JsonSize["False"] = 5] = "False";
+    JsonSize[JsonSize["Quote"] = 1] = "Quote";
+    JsonSize[JsonSize["Colon"] = 1] = "Colon";
+    JsonSize[JsonSize[// eslint-disable-next-line @typescript-eslint/no-shadow
+    "Date"] = 24] = "Date";
+})(JsonSize || (JsonSize = {}));
+const ESCAPE_CHARACTERS_REGEXP = /"|\\|\n|\r|\t/gu;
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        let proto = value;
+        while(Object.getPrototypeOf(proto) !== null){
+            proto = Object.getPrototypeOf(proto);
+        }
+        return Object.getPrototypeOf(value) === proto;
+    } catch (_) {
+        return false;
+    }
+}
+function isASCII(character) {
+    return character.charCodeAt(0) <= 127;
+}
+function calculateStringSize(value) {
+    const size = value.split('').reduce((total, character)=>{
+        if (isASCII(character)) {
+            return total + 1;
+        }
+        return total + 2;
+    }, 0);
+    // Also detect characters that need backslash escape
+    return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;
+}
+function calculateNumberSize(value) {
+    return value.toString().length;
+}
+
+//# sourceMappingURL=misc.js.map

package/dist/cjs/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/misc.ts"],"sourcesContent":["//\n// Types\n//\n\n/**\n * Makes every specified property of the specified object type mutable.\n *\n * @template ObjectValue - The object whose readonly properties to make mutable.\n * @template TargetKey - The property key(s) to make mutable.\n */\nexport type Mutable<\n  ObjectValue extends Record<string, unknown>,\n  TargetKey extends keyof ObjectValue,\n> = {\n  -readonly [Key in keyof Pick<ObjectValue, TargetKey>]: ObjectValue[Key];\n} & {\n  [Key in keyof Omit<ObjectValue, TargetKey>]: ObjectValue[Key];\n};\n\n/**\n * Useful for representing some value that _might_ be present and / or complete.\n *\n * @template Value - The value that might be present or complete.\n */\nexport type PartialOrAbsent<Value> = Partial<Value> | null | undefined;\n\n/**\n * Like {@link Array}, but always non-empty.\n *\n * @template Element - The non-empty array member type.\n */\nexport type NonEmptyArray<Element> = [Element, ...Element[]];\n\n/**\n * A JavaScript object that is not `null`, a function, or an array.\n */\nexport type RuntimeObject = Record<PropertyKey, unknown>;\n\n//\n// Type Guards\n//\n\n/**\n * A {@link NonEmptyArray} type guard.\n *\n * @template Element - The non-empty array member type.\n * @param value - The value to check.\n * @returns Whether the value is a non-empty array.\n */\nexport function isNonEmptyArray<Element>(\n  value: Element[],\n): value is NonEmptyArray<Element> {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard for \"nullishness\".\n *\n * @param value - Any value.\n * @returns `true` if the value is null or undefined, `false` otherwise.\n */\nexport function isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * A type guard for {@link RuntimeObject}.\n *\n * @param value - The value to check.\n * @returns Whether the specified value has a runtime type of `object` and is\n * neither `null` nor an `Array`.\n */\nexport function isObject(value: unknown): value is RuntimeObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);\n}\n\n//\n// Other utility functions\n//\n\n/**\n * A type guard for ensuring an object has a property.\n *\n * @param objectToCheck - The object to check.\n * @param name - The property name to check for.\n * @returns Whether the specified object has an own property with the specified\n * name, regardless of whether it is enumerable or not.\n */\nexport const hasProperty = <\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  ObjectToCheck extends Object,\n  Property extends PropertyKey,\n>(\n  objectToCheck: ObjectToCheck,\n  name: Property,\n): objectToCheck is ObjectToCheck &\n  Record<\n    Property,\n    Property extends keyof ObjectToCheck ? ObjectToCheck[Property] : unknown\n  > => Object.hasOwnProperty.call(objectToCheck, name);\n\n/**\n * `Object.getOwnPropertyNames()` is intentionally generic: it returns the\n * immediate property names of an object, but it cannot make guarantees about\n * the contents of that object, so the type of the property names is merely\n * `string[]`. While this is technically accurate, it is also unnecessary if we\n * have an object with a type that we own (such as an enum).\n *\n * @param object - The plain object.\n * @returns The own property names of the object which are assigned a type\n * derived from the object itself.\n */\nexport function getKnownPropertyNames<Key extends PropertyKey>(\n  object: Partial<Record<Key, any>>,\n): Key[] {\n  return Object.getOwnPropertyNames(object) as Key[];\n}\n\nexport type PlainObject = Record<number | string | symbol, unknown>;\n\n/**\n * Predefined sizes (in Bytes) of specific parts of JSON structure.\n */\nexport enum JsonSize {\n  Null = 4,\n  Comma = 1,\n  Wrapper = 1,\n  True = 4,\n  False = 5,\n  Quote = 1,\n  Colon = 1,\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  Date = 24,\n}\n\n/**\n * Regular expression with pattern matching for (special) escaped characters.\n */\nexport const ESCAPE_CHARACTERS_REGEXP = /\"|\\\\|\\n|\\r|\\t/gu;\n\n/**\n * Check if the value is plain object.\n *\n * @param value - Value to be checked.\n * @returns True if an object is the plain JavaScript object,\n * false if the object is not plain (e.g. function).\n */\nexport function isPlainObject(value: unknown): value is PlainObject {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  try {\n    let proto = value;\n    while (Object.getPrototypeOf(proto) !== null) {\n      proto = Object.getPrototypeOf(proto);\n    }\n\n    return Object.getPrototypeOf(value) === proto;\n  } catch (_) {\n    return false;\n  }\n}\n\n/**\n * Check if character is ASCII.\n *\n * @param character - Character.\n * @returns True if a character code is ASCII, false if not.\n */\nexport function isASCII(character: string) {\n  return character.charCodeAt(0) <= 127;\n}\n\n/**\n * Calculate string size.\n *\n * @param value - String value to calculate size.\n * @returns Number of bytes used to store whole string value.\n */\nexport function calculateStringSize(value: string): number {\n  const size = value.split('').reduce((total, character) => {\n    if (isASCII(character)) {\n      return total + 1;\n    }\n    return total + 2;\n  }, 0);\n\n  // Also detect characters that need backslash escape\n  return size + (value.match(ESCAPE_CHARACTERS_REGEXP) ?? []).length;\n}\n\n/**\n * Calculate size of a number ofter JSON serialization.\n *\n * @param value - Number value to calculate size.\n * @returns Number of bytes used to store whole number in JSON.\n */\nexport function calculateNumberSize(value: number): number {\n  return value.toString().length;\n}\n"],"names":["isNonEmptyArray","isNullOrUndefined","isObject","hasProperty","getKnownPropertyNames","ESCAPE_CHARACTERS_REGEXP","isPlainObject","isASCII","calculateStringSize","calculateNumberSize","value","Array","isArray","length","undefined","Boolean","objectToCheck","name","Object","hasOwnProperty","call","object","getOwnPropertyNames","JsonSize","Null","Comma","Wrapper","True","False","Quote","Colon","Date","proto","getPrototypeOf","_","character","charCodeAt","size","split","reduce","total","match","toString"],"mappings":"AAAA,EAAE;AACF,QAAQ;AACR,EAAE;AAEF;;;;;CAKC;;;;;;;;;;;;;;IAwCeA,eAAe;eAAfA;;IAYAC,iBAAiB;eAAjBA;;IAWAC,QAAQ;eAARA;;IAgBHC,WAAW;eAAXA;;IAwBGC,qBAAqB;eAArBA;;IA0BHC,wBAAwB;eAAxBA;;IASGC,aAAa;eAAbA;;IAuBAC,OAAO;eAAPA;;IAUAC,mBAAmB;eAAnBA;;IAkBAC,mBAAmB;eAAnBA;;;AArJT,SAAST,gBACdU,KAAgB;IAEhB,OAAOC,MAAMC,OAAO,CAACF,UAAUA,MAAMG,MAAM,GAAG;AAChD;AAQO,SAASZ,kBAAkBS,KAAc;IAC9C,OAAOA,UAAU,QAAQA,UAAUI;AACrC;AASO,SAASZ,SAASQ,KAAc;IACrC,OAAOK,QAAQL,UAAU,OAAOA,UAAU,YAAY,CAACC,MAAMC,OAAO,CAACF;AACvE;AAcO,MAAMP,cAAc,CAKzBa,eACAC,OAKKC,OAAOC,cAAc,CAACC,IAAI,CAACJ,eAAeC;AAa1C,SAASb,sBACdiB,MAAiC;IAEjC,OAAOH,OAAOI,mBAAmB,CAACD;AACpC;IAOO;UAAKE,QAAQ;IAARA,SAAAA,SACVC,UAAO,KAAPA;IADUD,SAAAA,SAEVE,WAAQ,KAARA;IAFUF,SAAAA,SAGVG,aAAU,KAAVA;IAHUH,SAAAA,SAIVI,UAAO,KAAPA;IAJUJ,SAAAA,SAKVK,WAAQ,KAARA;IALUL,SAAAA,SAMVM,WAAQ,KAARA;IANUN,SAAAA,SAOVO,WAAQ,KAARA;IAPUP,SAAAA,SAQV,wDAAwD;IACxDQ,UAAO,MAAPA;GATUR,aAAAA;AAeL,MAAMlB,2BAA2B;AASjC,SAASC,cAAcI,KAAc;IAC1C,IAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;QAC/C,OAAO;IACT;IAEA,IAAI;QACF,IAAIsB,QAAQtB;QACZ,MAAOQ,OAAOe,cAAc,CAACD,WAAW,KAAM;YAC5CA,QAAQd,OAAOe,cAAc,CAACD;QAChC;QAEA,OAAOd,OAAOe,cAAc,CAACvB,WAAWsB;IAC1C,EAAE,OAAOE,GAAG;QACV,OAAO;IACT;AACF;AAQO,SAAS3B,QAAQ4B,SAAiB;IACvC,OAAOA,UAAUC,UAAU,CAAC,MAAM;AACpC;AAQO,SAAS5B,oBAAoBE,KAAa;IAC/C,MAAM2B,OAAO3B,MAAM4B,KAAK,CAAC,IAAIC,MAAM,CAAC,CAACC,OAAOL;QAC1C,IAAI5B,QAAQ4B,YAAY;YACtB,OAAOK,QAAQ;QACjB;QACA,OAAOA,QAAQ;IACjB,GAAG;IAEH,oDAAoD;IACpD,OAAOH,OAAO,AAAC3B,CAAAA,MAAM+B,KAAK,CAACpC,6BAA6B,EAAE,AAAD,EAAGQ,MAAM;AACpE;AAQO,SAASJ,oBAAoBC,KAAa;IAC/C,OAAOA,MAAMgC,QAAQ,GAAG7B,MAAM;AAChC"}

package/dist/cjs/number.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    numberToHex: function() {
+        return numberToHex;
+    },
+    bigIntToHex: function() {
+        return bigIntToHex;
+    },
+    hexToNumber: function() {
+        return hexToNumber;
+    },
+    hexToBigInt: function() {
+        return hexToBigInt;
+    }
+});
+const _assert = require("./assert");
+const _hex = require("./hex");
+const numberToHex = (value)=>{
+    (0, _assert.assert)(typeof value === 'number', 'Value must be a number.');
+    (0, _assert.assert)(value >= 0, 'Value must be a non-negative number.');
+    (0, _assert.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToHex` instead.');
+    return (0, _hex.add0x)(value.toString(16));
+};
+const bigIntToHex = (value)=>{
+    (0, _assert.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, _assert.assert)(value >= 0, 'Value must be a non-negative bigint.');
+    return (0, _hex.add0x)(value.toString(16));
+};
+const hexToNumber = (value)=>{
+    (0, _hex.assertIsHexString)(value);
+    // `parseInt` accepts values without the "0x"-prefix, whereas `Number` does
+    // not. Using this is slightly faster than `Number(add0x(value))`.
+    const numberValue = parseInt(value, 16);
+    (0, _assert.assert)(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
+    return numberValue;
+};
+const hexToBigInt = (value)=>{
+    (0, _hex.assertIsHexString)(value);
+    // The `BigInt` constructor requires the "0x"-prefix to parse a hex string.
+    return BigInt((0, _hex.add0x)(value));
+};
+
+//# sourceMappingURL=number.js.map

package/dist/cjs/number.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/number.ts"],"sourcesContent":["import { assert } from './assert';\nimport { add0x, assertIsHexString } from './hex';\n\n/**\n * Convert a number to a hexadecimal string. This verifies that the number is a\n * non-negative safe integer.\n *\n * To convert a `bigint` to a hexadecimal string instead, use\n * {@link bigIntToHex}.\n *\n * @example\n * ```typescript\n * numberToHex(0); // '0x0'\n * numberToHex(1); // '0x1'\n * numberToHex(16); // '0x10'\n * ```\n * @param value - The number to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the number is not a non-negative safe integer.\n */\nexport const numberToHex = (value: number): string => {\n  assert(typeof value === 'number', 'Value must be a number.');\n  assert(value >= 0, 'Value must be a non-negative number.');\n  assert(\n    Number.isSafeInteger(value),\n    'Value is not a safe integer. Use `bigIntToHex` instead.',\n  );\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`\n * is a non-negative integer.\n *\n * To convert a number to a hexadecimal string instead, use {@link numberToHex}.\n *\n * @example\n * ```typescript\n * bigIntToHex(0n); // '0x0'\n * bigIntToHex(1n); // '0x1'\n * bigIntToHex(16n); // '0x10'\n * ```\n * @param value - The `bigint` to convert to a hexadecimal string.\n * @returns The hexadecimal string, with the \"0x\"-prefix.\n * @throws If the `bigint` is not a non-negative integer.\n */\nexport const bigIntToHex = (value: bigint): string => {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= 0, 'Value must be a non-negative bigint.');\n\n  return add0x(value.toString(16));\n};\n\n/**\n * Convert a hexadecimal string to a number. This verifies that the string is a\n * valid hex string, and that the resulting number is a safe integer. Both\n * \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a `bigint` instead, use\n * {@link hexToBigInt}.\n *\n * @example\n * ```typescript\n * hexToNumber('0x0'); // 0\n * hexToNumber('0x1'); // 1\n * hexToNumber('0x10'); // 16\n * ```\n * @param value - The hexadecimal string to convert to a number.\n * @returns The number.\n * @throws If the value is not a valid hexadecimal string, or if the resulting\n * number is not a safe integer.\n */\nexport const hexToNumber = (value: string): number => {\n  assertIsHexString(value);\n\n  // `parseInt` accepts values without the \"0x\"-prefix, whereas `Number` does\n  // not. Using this is slightly faster than `Number(add0x(value))`.\n  const numberValue = parseInt(value, 16);\n\n  assert(\n    Number.isSafeInteger(numberValue),\n    'Value is not a safe integer. Use `hexToBigInt` instead.',\n  );\n\n  return numberValue;\n};\n\n/**\n * Convert a hexadecimal string to a `bigint`. This verifies that the string is\n * a valid hex string. Both \"0x\"-prefixed and unprefixed strings are supported.\n *\n * To convert a hexadecimal string to a number instead, use {@link hexToNumber}.\n *\n * @example\n * ```typescript\n * hexToBigInt('0x0'); // 0n\n * hexToBigInt('0x1'); // 1n\n * hexToBigInt('0x10'); // 16n\n * ```\n * @param value - The hexadecimal string to convert to a `bigint`.\n * @returns The `bigint`.\n * @throws If the value is not a valid hexadecimal string.\n */\nexport const hexToBigInt = (value: string): bigint => {\n  assertIsHexString(value);\n\n  // The `BigInt` constructor requires the \"0x\"-prefix to parse a hex string.\n  return BigInt(add0x(value));\n};\n"],"names":["numberToHex","bigIntToHex","hexToNumber","hexToBigInt","value","assert","Number","isSafeInteger","add0x","toString","assertIsHexString","numberValue","parseInt","BigInt"],"mappings":";;;;;;;;;;;IAoBaA,WAAW;eAAXA;;IA2BAC,WAAW;eAAXA;;IA0BAC,WAAW;eAAXA;;IA+BAC,WAAW;eAAXA;;;wBAxGU;qBACkB;AAmBlC,MAAMH,cAAc,CAACI;IAC1BC,IAAAA,cAAM,EAAC,OAAOD,UAAU,UAAU;IAClCC,IAAAA,cAAM,EAACD,SAAS,GAAG;IACnBC,IAAAA,cAAM,EACJC,OAAOC,aAAa,CAACH,QACrB;IAGF,OAAOI,IAAAA,UAAK,EAACJ,MAAMK,QAAQ,CAAC;AAC9B;AAkBO,MAAMR,cAAc,CAACG;IAC1BC,IAAAA,cAAM,EAAC,OAAOD,UAAU,UAAU;IAClCC,IAAAA,cAAM,EAACD,SAAS,GAAG;IAEnB,OAAOI,IAAAA,UAAK,EAACJ,MAAMK,QAAQ,CAAC;AAC9B;AAqBO,MAAMP,cAAc,CAACE;IAC1BM,IAAAA,sBAAiB,EAACN;IAElB,2EAA2E;IAC3E,kEAAkE;IAClE,MAAMO,cAAcC,SAASR,OAAO;IAEpCC,IAAAA,cAAM,EACJC,OAAOC,aAAa,CAACI,cACrB;IAGF,OAAOA;AACT;AAkBO,MAAMR,cAAc,CAACC;IAC1BM,IAAAA,sBAAiB,EAACN;IAElB,2EAA2E;IAC3E,OAAOS,OAAOL,IAAAA,UAAK,EAACJ;AACtB"}

package/dist/cjs/opaque.js

@@ -0,0 +1,8 @@
+// We use a symbol property name instead of { _type: Brand }, because that would show up in IDE suggestions,
+// while internal symbols do not.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=opaque.js.map

package/dist/cjs/opaque.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/opaque.ts"],"sourcesContent":["// We use a symbol property name instead of { _type: Brand }, because that would show up in IDE suggestions,\n// while internal symbols do not.\ndeclare const brand: unique symbol;\nexport type Opaque<Base, Brand extends symbol> = Base & { [brand]: Brand };\n"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,iCAAiC"}

package/dist/cjs/time.js

@@ -0,0 +1,63 @@
+/**
+ * Common duration constants, in milliseconds.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Duration: function() {
+        return Duration;
+    },
+    inMilliseconds: function() {
+        return inMilliseconds;
+    },
+    timeSince: function() {
+        return timeSince;
+    }
+});
+var Duration;
+(function(Duration) {
+    Duration[Duration[/**
+   * A millisecond.
+   */ "Millisecond"] = 1] = "Millisecond";
+    Duration[Duration[/**
+   * A second, in milliseconds.
+   */ "Second"] = 1000] = "Second";
+    Duration[Duration[/**
+   * A minute, in milliseconds.
+   */ "Minute"] = 60000] = "Minute";
+    Duration[Duration[/**
+   * An hour, in milliseconds.
+   */ "Hour"] = 3600000] = "Hour";
+    Duration[Duration[/**
+   * A day, in milliseconds.
+   */ "Day"] = 86400000] = "Day";
+    Duration[Duration[/**
+   * A week, in milliseconds.
+   */ "Week"] = 604800000] = "Week";
+    Duration[Duration[/**
+   * A year, in milliseconds.
+   */ "Year"] = 31536000000] = "Year";
+})(Duration || (Duration = {}));
+const isNonNegativeInteger = (number)=>Number.isInteger(number) && number >= 0;
+const assertIsNonNegativeInteger = (number, name)=>{
+    if (!isNonNegativeInteger(number)) {
+        throw new Error(`"${name}" must be a non-negative integer. Received: "${number}".`);
+    }
+};
+function inMilliseconds(count, duration) {
+    assertIsNonNegativeInteger(count, 'count');
+    return count * duration;
+}
+function timeSince(timestamp) {
+    assertIsNonNegativeInteger(timestamp, 'timestamp');
+    return Date.now() - timestamp;
+}
+
+//# sourceMappingURL=time.js.map

package/dist/cjs/time.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/time.ts"],"sourcesContent":["/**\n * Common duration constants, in milliseconds.\n */\nexport enum Duration {\n  /**\n   * A millisecond.\n   */\n  Millisecond = 1,\n\n  /**\n   * A second, in milliseconds.\n   */\n  Second = 1000, // Millisecond * 1000\n\n  /**\n   * A minute, in milliseconds.\n   */\n  Minute = 60_000, // Second * 60\n\n  /**\n   * An hour, in milliseconds.\n   */\n  Hour = 3_600_000, // Minute * 60\n\n  /**\n   * A day, in milliseconds.\n   */\n  Day = 86_400_000, // Hour * 24\n\n  /**\n   * A week, in milliseconds.\n   */\n  Week = 604_800_000, // Day * 7\n\n  /**\n   * A year, in milliseconds.\n   */\n  Year = 31_536_000_000, // Day * 365\n}\n\nconst isNonNegativeInteger = (number: number) =>\n  Number.isInteger(number) && number >= 0;\n\nconst assertIsNonNegativeInteger = (number: number, name: string) => {\n  if (!isNonNegativeInteger(number)) {\n    throw new Error(\n      `\"${name}\" must be a non-negative integer. Received: \"${number}\".`,\n    );\n  }\n};\n\n/**\n * Calculates the millisecond value of the specified number of units of time.\n *\n * @param count - The number of units of time.\n * @param duration - The unit of time to count.\n * @returns The count multiplied by the specified duration.\n */\nexport function inMilliseconds(count: number, duration: Duration): number {\n  assertIsNonNegativeInteger(count, 'count');\n  return count * duration;\n}\n\n/**\n * Gets the milliseconds since a particular Unix epoch timestamp.\n *\n * @param timestamp - A Unix millisecond timestamp.\n * @returns The number of milliseconds elapsed since the specified timestamp.\n */\nexport function timeSince(timestamp: number): number {\n  assertIsNonNegativeInteger(timestamp, 'timestamp');\n  return Date.now() - timestamp;\n}\n"],"names":["inMilliseconds","timeSince","Duration","Millisecond","Second","Minute","Hour","Day","Week","Year","isNonNegativeInteger","number","Number","isInteger","assertIsNonNegativeInteger","name","Error","count","duration","timestamp","Date","now"],"mappings":"AAAA;;CAEC;;;;;;;;;;;;;;IAwDeA,cAAc;eAAdA;;IAWAC,SAAS;eAATA;;;IAlET;UAAKC,QAAQ;IAARA,SAAAA,SACV;;GAEC,GACDC,iBAAc,KAAdA;IAJUD,SAAAA,SAMV;;GAEC,GACDE,YAAS,QAATA;IATUF,SAAAA,SAWV;;GAEC,GACDG,YAAS,SAATA;IAdUH,SAAAA,SAgBV;;GAEC,GACDI,UAAO,WAAPA;IAnBUJ,SAAAA,SAqBV;;GAEC,GACDK,SAAM,YAANA;IAxBUL,SAAAA,SA0BV;;GAEC,GACDM,UAAO,aAAPA;IA7BUN,SAAAA,SA+BV;;GAEC,GACDO,UAAO,eAAPA;GAlCUP,aAAAA;AAqCZ,MAAMQ,uBAAuB,CAACC,SAC5BC,OAAOC,SAAS,CAACF,WAAWA,UAAU;AAExC,MAAMG,6BAA6B,CAACH,QAAgBI;IAClD,IAAI,CAACL,qBAAqBC,SAAS;QACjC,MAAM,IAAIK,MACR,CAAC,CAAC,EAAED,KAAK,6CAA6C,EAAEJ,OAAO,EAAE,CAAC;IAEtE;AACF;AASO,SAASX,eAAeiB,KAAa,EAAEC,QAAkB;IAC9DJ,2BAA2BG,OAAO;IAClC,OAAOA,QAAQC;AACjB;AAQO,SAASjB,UAAUkB,SAAiB;IACzCL,2BAA2BK,WAAW;IACtC,OAAOC,KAAKC,GAAG,KAAKF;AACtB"}

package/dist/cjs/transaction-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=transaction-types.js.map

package/dist/cjs/transaction-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transaction-types.ts"],"names":[],"mappings":""}