@metamask/utils 6.1.0 → 7.0.0

package/dist/cjs/collections.js

@@ -0,0 +1,157 @@
+/**
+ * A {@link ReadonlyMap} that cannot be modified after instantiation.
+ * The implementation uses an inner map hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this map.
+ */ "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, {
+    FrozenMap: function() {
+        return FrozenMap;
+    },
+    FrozenSet: function() {
+        return FrozenSet;
+    }
+});
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _map = /*#__PURE__*/ new WeakMap();
+let _Symbol_iterator = Symbol.iterator;
+class FrozenMap {
+    get size() {
+        return _class_private_field_get(this, _map).size;
+    }
+    [_Symbol_iterator]() {
+        return _class_private_field_get(this, _map)[Symbol.iterator]();
+    }
+    entries() {
+        return _class_private_field_get(this, _map).entries();
+    }
+    forEach(callbackfn, thisArg) {
+        // We have to wrap the specified callback in order to prevent it from
+        // receiving a reference to the inner map.
+        return _class_private_field_get(this, _map).forEach((value, key, _map)=>callbackfn.call(thisArg, value, key, this));
+    }
+    get(key) {
+        return _class_private_field_get(this, _map).get(key);
+    }
+    has(key) {
+        return _class_private_field_get(this, _map).has(key);
+    }
+    keys() {
+        return _class_private_field_get(this, _map).keys();
+    }
+    values() {
+        return _class_private_field_get(this, _map).values();
+    }
+    toString() {
+        return `FrozenMap(${this.size}) {${this.size > 0 ? ` ${[
+            ...this.entries()
+        ].map(([key, value])=>`${String(key)} => ${String(value)}`).join(', ')} ` : ''}}`;
+    }
+    constructor(entries){
+        _class_private_field_init(this, _map, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _map, new Map(entries));
+        Object.freeze(this);
+    }
+}
+var _set = /*#__PURE__*/ new WeakMap();
+let _Symbol_iterator1 = Symbol.iterator;
+/**
+ * A {@link ReadonlySet} that cannot be modified after instantiation.
+ * The implementation uses an inner set hidden via a private field, and the
+ * immutability guarantee relies on it being impossible to get a reference
+ * to this set.
+ */ class FrozenSet {
+    get size() {
+        return _class_private_field_get(this, _set).size;
+    }
+    [_Symbol_iterator1]() {
+        return _class_private_field_get(this, _set)[Symbol.iterator]();
+    }
+    entries() {
+        return _class_private_field_get(this, _set).entries();
+    }
+    forEach(callbackfn, thisArg) {
+        // We have to wrap the specified callback in order to prevent it from
+        // receiving a reference to the inner set.
+        return _class_private_field_get(this, _set).forEach((value, value2, _set)=>callbackfn.call(thisArg, value, value2, this));
+    }
+    has(value) {
+        return _class_private_field_get(this, _set).has(value);
+    }
+    keys() {
+        return _class_private_field_get(this, _set).keys();
+    }
+    values() {
+        return _class_private_field_get(this, _set).values();
+    }
+    toString() {
+        return `FrozenSet(${this.size}) {${this.size > 0 ? ` ${[
+            ...this.values()
+        ].map((member)=>String(member)).join(', ')} ` : ''}}`;
+    }
+    constructor(values){
+        _class_private_field_init(this, _set, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _set, new Set(values));
+        Object.freeze(this);
+    }
+}
+Object.freeze(FrozenMap);
+Object.freeze(FrozenMap.prototype);
+Object.freeze(FrozenSet);
+Object.freeze(FrozenSet.prototype);
+
+//# sourceMappingURL=collections.js.map

package/dist/cjs/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collections.ts"],"sourcesContent":["/**\n * A {@link ReadonlyMap} that cannot be modified after instantiation.\n * The implementation uses an inner map hidden via a private field, and the\n * immutability guarantee relies on it being impossible to get a reference\n * to this map.\n */\nclass FrozenMap<Key, Value> implements ReadonlyMap<Key, Value> {\n  readonly #map: Map<Key, Value>;\n\n  public get size() {\n    return this.#map.size;\n  }\n\n  public [Symbol.iterator]() {\n    return this.#map[Symbol.iterator]();\n  }\n\n  constructor(entries?: readonly (readonly [Key, Value])[] | null) {\n    this.#map = new Map<Key, Value>(entries);\n    Object.freeze(this);\n  }\n\n  public entries() {\n    return this.#map.entries();\n  }\n\n  public forEach(\n    callbackfn: (value: Value, key: Key, map: this) => void,\n    thisArg?: any,\n  ): void {\n    // We have to wrap the specified callback in order to prevent it from\n    // receiving a reference to the inner map.\n    return this.#map.forEach((value: Value, key: Key, _map: unknown) =>\n      callbackfn.call(thisArg, value, key, this),\n    );\n  }\n\n  public get(key: Key) {\n    return this.#map.get(key);\n  }\n\n  public has(key: Key) {\n    return this.#map.has(key);\n  }\n\n  public keys() {\n    return this.#map.keys();\n  }\n\n  public values() {\n    return this.#map.values();\n  }\n\n  public toString(): string {\n    return `FrozenMap(${this.size}) {${\n      this.size > 0\n        ? ` ${[...this.entries()]\n            .map(([key, value]) => `${String(key)} => ${String(value)}`)\n            .join(', ')} `\n        : ''\n    }}`;\n  }\n}\n\n/**\n * A {@link ReadonlySet} that cannot be modified after instantiation.\n * The implementation uses an inner set hidden via a private field, and the\n * immutability guarantee relies on it being impossible to get a reference\n * to this set.\n */\nclass FrozenSet<Value> implements ReadonlySet<Value> {\n  readonly #set: Set<Value>;\n\n  public get size() {\n    return this.#set.size;\n  }\n\n  public [Symbol.iterator]() {\n    return this.#set[Symbol.iterator]();\n  }\n\n  constructor(values?: readonly Value[] | null) {\n    this.#set = new Set<Value>(values);\n    Object.freeze(this);\n  }\n\n  public entries() {\n    return this.#set.entries();\n  }\n\n  public forEach(\n    callbackfn: (value: Value, value2: Value, set: this) => void,\n    thisArg?: any,\n  ): void {\n    // We have to wrap the specified callback in order to prevent it from\n    // receiving a reference to the inner set.\n    return this.#set.forEach((value: Value, value2: Value, _set: unknown) =>\n      callbackfn.call(thisArg, value, value2, this),\n    );\n  }\n\n  public has(value: Value) {\n    return this.#set.has(value);\n  }\n\n  public keys() {\n    return this.#set.keys();\n  }\n\n  public values() {\n    return this.#set.values();\n  }\n\n  public toString(): string {\n    return `FrozenSet(${this.size}) {${\n      this.size > 0\n        ? ` ${[...this.values()].map((member) => String(member)).join(', ')} `\n        : ''\n    }}`;\n  }\n}\n\nObject.freeze(FrozenMap);\nObject.freeze(FrozenMap.prototype);\n\nObject.freeze(FrozenSet);\nObject.freeze(FrozenSet.prototype);\n\nexport { FrozenMap, FrozenSet };\n"],"names":["FrozenMap","FrozenSet","Symbol","iterator","size","map","entries","forEach","callbackfn","thisArg","value","key","_map","call","get","has","keys","values","toString","String","join","constructor","Map","Object","freeze","set","value2","_set","member","Set","prototype"],"mappings":"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"}

package/dist/cjs/encryption-types.js

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

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

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

package/dist/cjs/hex.js

@@ -0,0 +1,107 @@
+"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, {
+    HexStruct: function() {
+        return HexStruct;
+    },
+    StrictHexStruct: function() {
+        return StrictHexStruct;
+    },
+    HexAddressStruct: function() {
+        return HexAddressStruct;
+    },
+    HexChecksumAddressStruct: function() {
+        return HexChecksumAddressStruct;
+    },
+    isHexString: function() {
+        return isHexString;
+    },
+    isStrictHexString: function() {
+        return isStrictHexString;
+    },
+    assertIsHexString: function() {
+        return assertIsHexString;
+    },
+    assertIsStrictHexString: function() {
+        return assertIsStrictHexString;
+    },
+    isValidHexAddress: function() {
+        return isValidHexAddress;
+    },
+    getChecksumAddress: function() {
+        return getChecksumAddress;
+    },
+    isValidChecksumAddress: function() {
+        return isValidChecksumAddress;
+    },
+    add0x: function() {
+        return add0x;
+    },
+    remove0x: function() {
+        return remove0x;
+    }
+});
+const _sha3 = require("@noble/hashes/sha3");
+const _superstruct = require("superstruct");
+const _assert = require("./assert");
+const _bytes = require("./bytes");
+const HexStruct = (0, _superstruct.pattern)((0, _superstruct.string)(), /^(?:0x)?[0-9a-f]+$/iu);
+const StrictHexStruct = (0, _superstruct.pattern)((0, _superstruct.string)(), /^0x[0-9a-f]+$/iu);
+const HexAddressStruct = (0, _superstruct.pattern)((0, _superstruct.string)(), /^0x[0-9a-f]{40}$/u);
+const HexChecksumAddressStruct = (0, _superstruct.pattern)((0, _superstruct.string)(), /^0x[0-9a-fA-F]{40}$/u);
+function isHexString(value) {
+    return (0, _superstruct.is)(value, HexStruct);
+}
+function isStrictHexString(value) {
+    return (0, _superstruct.is)(value, StrictHexStruct);
+}
+function assertIsHexString(value) {
+    (0, _assert.assert)(isHexString(value), 'Value must be a hexadecimal string.');
+}
+function assertIsStrictHexString(value) {
+    (0, _assert.assert)(isStrictHexString(value), 'Value must be a hexadecimal string, starting with "0x".');
+}
+function isValidHexAddress(possibleAddress) {
+    return (0, _superstruct.is)(possibleAddress, HexAddressStruct) || isValidChecksumAddress(possibleAddress);
+}
+function getChecksumAddress(address) {
+    (0, _assert.assert)((0, _superstruct.is)(address, HexChecksumAddressStruct), 'Invalid hex address.');
+    const unPrefixed = remove0x(address.toLowerCase());
+    const unPrefixedHash = remove0x((0, _bytes.bytesToHex)((0, _sha3.keccak_256)(unPrefixed)));
+    return `0x${unPrefixed.split('').map((character, nibbleIndex)=>{
+        const hashCharacter = unPrefixedHash[nibbleIndex];
+        (0, _assert.assert)((0, _superstruct.is)(hashCharacter, (0, _superstruct.string)()), 'Hash shorter than address.');
+        return parseInt(hashCharacter, 16) > 7 ? character.toUpperCase() : character;
+    }).join('')}`;
+}
+function isValidChecksumAddress(possibleChecksum) {
+    if (!(0, _superstruct.is)(possibleChecksum, HexChecksumAddressStruct)) {
+        return false;
+    }
+    return getChecksumAddress(possibleChecksum) === possibleChecksum;
+}
+function add0x(hexadecimal) {
+    if (hexadecimal.startsWith('0x')) {
+        return hexadecimal;
+    }
+    if (hexadecimal.startsWith('0X')) {
+        return `0x${hexadecimal.substring(2)}`;
+    }
+    return `0x${hexadecimal}`;
+}
+function remove0x(hexadecimal) {
+    if (hexadecimal.startsWith('0x') || hexadecimal.startsWith('0X')) {
+        return hexadecimal.substring(2);
+    }
+    return hexadecimal;
+}
+
+//# sourceMappingURL=hex.js.map

package/dist/cjs/hex.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hex.ts"],"sourcesContent":["import { keccak_256 as keccak256 } from '@noble/hashes/sha3';\nimport type { Struct } from 'superstruct';\nimport { is, pattern, string } from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex } from './bytes';\n\nexport type Hex = `0x${string}`;\n\nexport const HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);\nexport const StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu) as Struct<\n  Hex,\n  null\n>;\nexport const HexAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-f]{40}$/u,\n) as Struct<Hex, null>;\nexport const HexChecksumAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-fA-F]{40}$/u,\n) as Struct<Hex, null>;\n\n/**\n * Check if a string is a valid hex string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isHexString(value: unknown): value is string {\n  return is(value, HexStruct);\n}\n\n/**\n * Strictly check if a string is a valid hex string. A valid hex string must\n * start with the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isStrictHexString(value: unknown): value is Hex {\n  return is(value, StrictHexStruct);\n}\n\n/**\n * Assert that a value is a valid hex string.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsHexString(value: unknown): asserts value is string {\n  assert(isHexString(value), 'Value must be a hexadecimal string.');\n}\n\n/**\n * Assert that a value is a valid hex string. A valid hex string must start with\n * the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsStrictHexString(value: unknown): asserts value is Hex {\n  assert(\n    isStrictHexString(value),\n    'Value must be a hexadecimal string, starting with \"0x\".',\n  );\n}\n\n/**\n * Validate that the passed prefixed hex string is an all-lowercase\n * hex address, or a valid mixed-case checksum address.\n *\n * @param possibleAddress - Input parameter to check against.\n * @returns Whether or not the input is a valid hex address.\n */\nexport function isValidHexAddress(possibleAddress: Hex) {\n  return (\n    is(possibleAddress, HexAddressStruct) ||\n    isValidChecksumAddress(possibleAddress)\n  );\n}\n\n/**\n * Encode a passed hex string as an ERC-55 mixed-case checksum address.\n *\n * @param address - The hex address to encode.\n * @returns The address encoded according to ERC-55.\n * @see https://eips.ethereum.org/EIPS/eip-55\n */\nexport function getChecksumAddress(address: Hex) {\n  assert(is(address, HexChecksumAddressStruct), 'Invalid hex address.');\n  const unPrefixed = remove0x(address.toLowerCase());\n  const unPrefixedHash = remove0x(bytesToHex(keccak256(unPrefixed)));\n  return `0x${unPrefixed\n    .split('')\n    .map((character, nibbleIndex) => {\n      const hashCharacter = unPrefixedHash[nibbleIndex];\n      assert(is(hashCharacter, string()), 'Hash shorter than address.');\n      return parseInt(hashCharacter, 16) > 7\n        ? character.toUpperCase()\n        : character;\n    })\n    .join('')}`;\n}\n\n/**\n * Validate that the passed hex string is a valid ERC-55 mixed-case\n * checksum address.\n *\n * @param possibleChecksum - The hex address to check.\n * @returns True if the address is a checksum address.\n */\nexport function isValidChecksumAddress(possibleChecksum: Hex) {\n  if (!is(possibleChecksum, HexChecksumAddressStruct)) {\n    return false;\n  }\n\n  return getChecksumAddress(possibleChecksum) === possibleChecksum;\n}\n\n/**\n * Add the `0x`-prefix to a hexadecimal string. If the string already has the\n * prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to add the prefix to.\n * @returns The prefixed hexadecimal string.\n */\nexport function add0x(hexadecimal: string): Hex {\n  if (hexadecimal.startsWith('0x')) {\n    return hexadecimal as Hex;\n  }\n\n  if (hexadecimal.startsWith('0X')) {\n    return `0x${hexadecimal.substring(2)}`;\n  }\n\n  return `0x${hexadecimal}`;\n}\n\n/**\n * Remove the `0x`-prefix from a hexadecimal string. If the string doesn't have\n * the prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to remove the prefix from.\n * @returns The un-prefixed hexadecimal string.\n */\nexport function remove0x(hexadecimal: string): string {\n  if (hexadecimal.startsWith('0x') || hexadecimal.startsWith('0X')) {\n    return hexadecimal.substring(2);\n  }\n\n  return hexadecimal;\n}\n"],"names":["HexStruct","StrictHexStruct","HexAddressStruct","HexChecksumAddressStruct","isHexString","isStrictHexString","assertIsHexString","assertIsStrictHexString","isValidHexAddress","getChecksumAddress","isValidChecksumAddress","add0x","remove0x","pattern","string","value","is","assert","possibleAddress","address","unPrefixed","toLowerCase","unPrefixedHash","bytesToHex","keccak256","split","map","character","nibbleIndex","hashCharacter","parseInt","toUpperCase","join","possibleChecksum","hexadecimal","startsWith","substring"],"mappings":";;;;;;;;;;;IASaA,SAAS;eAATA;;IACAC,eAAe;eAAfA;;IAIAC,gBAAgB;eAAhBA;;IAIAC,wBAAwB;eAAxBA;;IAWGC,WAAW;eAAXA;;IAWAC,iBAAiB;eAAjBA;;IAUAC,iBAAiB;eAAjBA;;IAWAC,uBAAuB;eAAvBA;;IAcAC,iBAAiB;eAAjBA;;IAcAC,kBAAkB;eAAlBA;;IAuBAC,sBAAsB;eAAtBA;;IAeAC,KAAK;eAALA;;IAmBAC,QAAQ;eAARA;;;sBAlJwB;6BAEJ;wBAEb;uBACI;AAIpB,MAAMZ,YAAYa,IAAAA,oBAAO,EAACC,IAAAA,mBAAM,KAAI;AACpC,MAAMb,kBAAkBY,IAAAA,oBAAO,EAACC,IAAAA,mBAAM,KAAI;AAI1C,MAAMZ,mBAAmBW,IAAAA,oBAAO,EACrCC,IAAAA,mBAAM,KACN;AAEK,MAAMX,2BAA2BU,IAAAA,oBAAO,EAC7CC,IAAAA,mBAAM,KACN;AASK,SAASV,YAAYW,KAAc;IACxC,OAAOC,IAAAA,eAAE,EAACD,OAAOf;AACnB;AASO,SAASK,kBAAkBU,KAAc;IAC9C,OAAOC,IAAAA,eAAE,EAACD,OAAOd;AACnB;AAQO,SAASK,kBAAkBS,KAAc;IAC9CE,IAAAA,cAAM,EAACb,YAAYW,QAAQ;AAC7B;AASO,SAASR,wBAAwBQ,KAAc;IACpDE,IAAAA,cAAM,EACJZ,kBAAkBU,QAClB;AAEJ;AASO,SAASP,kBAAkBU,eAAoB;IACpD,OACEF,IAAAA,eAAE,EAACE,iBAAiBhB,qBACpBQ,uBAAuBQ;AAE3B;AASO,SAAST,mBAAmBU,OAAY;IAC7CF,IAAAA,cAAM,EAACD,IAAAA,eAAE,EAACG,SAAShB,2BAA2B;IAC9C,MAAMiB,aAAaR,SAASO,QAAQE,WAAW;IAC/C,MAAMC,iBAAiBV,SAASW,IAAAA,iBAAU,EAACC,IAAAA,gBAAS,EAACJ;IACrD,OAAO,CAAC,EAAE,EAAEA,WACTK,KAAK,CAAC,IACNC,GAAG,CAAC,CAACC,WAAWC;QACf,MAAMC,gBAAgBP,cAAc,CAACM,YAAY;QACjDX,IAAAA,cAAM,EAACD,IAAAA,eAAE,EAACa,eAAef,IAAAA,mBAAM,MAAK;QACpC,OAAOgB,SAASD,eAAe,MAAM,IACjCF,UAAUI,WAAW,KACrBJ;IACN,GACCK,IAAI,CAAC,IAAI,CAAC;AACf;AASO,SAAStB,uBAAuBuB,gBAAqB;IAC1D,IAAI,CAACjB,IAAAA,eAAE,EAACiB,kBAAkB9B,2BAA2B;QACnD,OAAO;IACT;IAEA,OAAOM,mBAAmBwB,sBAAsBA;AAClD;AASO,SAAStB,MAAMuB,WAAmB;IACvC,IAAIA,YAAYC,UAAU,CAAC,OAAO;QAChC,OAAOD;IACT;IAEA,IAAIA,YAAYC,UAAU,CAAC,OAAO;QAChC,OAAO,CAAC,EAAE,EAAED,YAAYE,SAAS,CAAC,GAAG,CAAC;IACxC;IAEA,OAAO,CAAC,EAAE,EAAEF,YAAY,CAAC;AAC3B;AASO,SAAStB,SAASsB,WAAmB;IAC1C,IAAIA,YAAYC,UAAU,CAAC,SAASD,YAAYC,UAAU,CAAC,OAAO;QAChE,OAAOD,YAAYE,SAAS,CAAC;IAC/B;IAEA,OAAOF;AACT"}

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./assert"), exports);
+_export_star(require("./base64"), exports);
+_export_star(require("./bytes"), exports);
+_export_star(require("./checksum"), exports);
+_export_star(require("./coercers"), exports);
+_export_star(require("./collections"), exports);
+_export_star(require("./encryption-types"), exports);
+_export_star(require("./hex"), exports);
+_export_star(require("./json"), exports);
+_export_star(require("./keyring"), exports);
+_export_star(require("./logging"), exports);
+_export_star(require("./misc"), exports);
+_export_star(require("./number"), exports);
+_export_star(require("./opaque"), exports);
+_export_star(require("./time"), exports);
+_export_star(require("./transaction-types"), exports);
+_export_star(require("./versions"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './assert';\nexport * from './base64';\nexport * from './bytes';\nexport * from './checksum';\nexport * from './coercers';\nexport * from './collections';\nexport * from './encryption-types';\nexport * from './hex';\nexport * from './json';\nexport * from './keyring';\nexport * from './logging';\nexport * from './misc';\nexport * from './number';\nexport * from './opaque';\nexport * from './time';\nexport * from './transaction-types';\nexport * from './versions';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA;qBACA"}

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