@metamask/utils 6.2.0 → 7.1.0

package/dist/cjs/coercers.js

@@ -0,0 +1,96 @@
+"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, {
+    createNumber: function() {
+        return createNumber;
+    },
+    createBigInt: function() {
+        return createBigInt;
+    },
+    createBytes: function() {
+        return createBytes;
+    },
+    createHex: function() {
+        return createHex;
+    }
+});
+const _superstruct = require("superstruct");
+const _assert = require("./assert");
+const _bytes = require("./bytes");
+const _hex = require("./hex");
+const NumberLikeStruct = (0, _superstruct.union)([
+    (0, _superstruct.number)(),
+    (0, _superstruct.bigint)(),
+    (0, _superstruct.string)(),
+    _hex.StrictHexStruct
+]);
+const NumberCoercer = (0, _superstruct.coerce)((0, _superstruct.number)(), NumberLikeStruct, Number);
+const BigIntCoercer = (0, _superstruct.coerce)((0, _superstruct.bigint)(), NumberLikeStruct, BigInt);
+const BytesLikeStruct = (0, _superstruct.union)([
+    _hex.StrictHexStruct,
+    (0, _superstruct.instance)(Uint8Array)
+]);
+const BytesCoercer = (0, _superstruct.coerce)((0, _superstruct.instance)(Uint8Array), (0, _superstruct.union)([
+    _hex.StrictHexStruct
+]), _bytes.hexToBytes);
+const HexCoercer = (0, _superstruct.coerce)(_hex.StrictHexStruct, (0, _superstruct.instance)(Uint8Array), _bytes.bytesToHex);
+function createNumber(value) {
+    try {
+        const result = (0, _superstruct.create)(value, NumberCoercer);
+        (0, _assert.assert)(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
+        return result;
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a number-like value, got "${value}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+function createBigInt(value) {
+    try {
+        // The `BigInt` constructor throws if the value is not a number-like value.
+        // There is no need to validate the value manually.
+        return (0, _superstruct.create)(value, BigIntCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a number-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+function createBytes(value) {
+    if (typeof value === 'string' && value.toLowerCase() === '0x') {
+        return new Uint8Array();
+    }
+    try {
+        return (0, _superstruct.create)(value, BytesCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+function createHex(value) {
+    if (value instanceof Uint8Array && value.length === 0 || typeof value === 'string' && value.toLowerCase() === '0x') {
+        return '0x';
+    }
+    try {
+        return (0, _superstruct.create)(value, HexCoercer);
+    } catch (error) {
+        if (error instanceof _superstruct.StructError) {
+            throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
+        }
+        /* istanbul ignore next */ throw error;
+    }
+}
+
+//# sourceMappingURL=coercers.js.map

package/dist/cjs/coercers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/coercers.ts"],"sourcesContent":["import type { Infer } from 'superstruct';\nimport {\n  bigint,\n  coerce,\n  create,\n  instance,\n  number,\n  string,\n  StructError,\n  union,\n} from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex, hexToBytes } from './bytes';\nimport type { Hex } from './hex';\nimport { StrictHexStruct } from './hex';\n\nconst NumberLikeStruct = union([number(), bigint(), string(), StrictHexStruct]);\nconst NumberCoercer = coerce(number(), NumberLikeStruct, Number);\nconst BigIntCoercer = coerce(bigint(), NumberLikeStruct, BigInt);\n\nconst BytesLikeStruct = union([StrictHexStruct, instance(Uint8Array)]);\nconst BytesCoercer = coerce(\n  instance(Uint8Array),\n  union([StrictHexStruct]),\n  hexToBytes,\n);\n\nconst HexCoercer = coerce(StrictHexStruct, instance(Uint8Array), bytesToHex);\n\nexport type NumberLike = Infer<typeof NumberLikeStruct>;\nexport type BytesLike = Infer<typeof BytesLikeStruct>;\n\n/**\n * Create a number from a number-like value.\n *\n * - If the value is a number, it is returned as-is.\n * - If the value is a `bigint`, it is converted to a number.\n * - If the value is a string, it is interpreted as a decimal number.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number.\n *\n * This validates that the value is a number-like value, and that the resulting\n * number is not `NaN` or `Infinity`.\n *\n * @example\n * ```typescript\n * const value = createNumber('0x010203');\n * console.log(value); // 66051\n *\n * const otherValue = createNumber(123n);\n * console.log(otherValue); // 123\n * ```\n * @param value - The value to create the number from.\n * @returns The created number.\n * @throws If the value is not a number-like value, or if the resulting number\n * is `NaN` or `Infinity`.\n */\nexport function createNumber(value: NumberLike): number {\n  try {\n    const result = create(value, NumberCoercer);\n\n    assert(\n      Number.isFinite(result),\n      `Expected a number-like value, got \"${value}\".`,\n    );\n\n    return result;\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(`Expected a number-like value, got \"${value}\".`);\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a `bigint` from a number-like value.\n *\n * - If the value is a number, it is converted to a `bigint`.\n * - If the value is a `bigint`, it is returned as-is.\n * - If the value is a string, it is interpreted as a decimal number and\n * converted to a `bigint`.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is\n * interpreted as a hexadecimal number and converted to a `bigint`.\n *\n * @example\n * ```typescript\n * const value = createBigInt('0x010203');\n * console.log(value); // 16909060n\n *\n * const otherValue = createBigInt(123);\n * console.log(otherValue); // 123n\n * ```\n * @param value - The value to create the bigint from.\n * @returns The created bigint.\n * @throws If the value is not a number-like value.\n */\nexport function createBigInt(value: NumberLike): bigint {\n  try {\n    // The `BigInt` constructor throws if the value is not a number-like value.\n    // There is no need to validate the value manually.\n    return create(value, BigIntCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a number-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a byte array from a bytes-like value.\n *\n * - If the value is a byte array, it is returned as-is.\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is interpreted\n * as a hexadecimal number and converted to a byte array.\n *\n * @example\n * ```typescript\n * const value = createBytes('0x010203');\n * console.log(value); // Uint8Array [ 1, 2, 3 ]\n *\n * const otherValue = createBytes('0x010203');\n * console.log(otherValue); // Uint8Array [ 1, 2, 3 ]\n * ```\n * @param value - The value to create the byte array from.\n * @returns The created byte array.\n * @throws If the value is not a bytes-like value.\n */\nexport function createBytes(value: BytesLike): Uint8Array {\n  if (typeof value === 'string' && value.toLowerCase() === '0x') {\n    return new Uint8Array();\n  }\n\n  try {\n    return create(value, BytesCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\n/**\n * Create a hexadecimal string from a bytes-like value.\n *\n * - If the value is a hex string (i.e., it starts with \"0x\"), it is returned\n * as-is.\n * - If the value is a `Uint8Array`, it is converted to a hex string.\n *\n * @example\n * ```typescript\n * const value = createHex(new Uint8Array([1, 2, 3]));\n * console.log(value); // '0x010203'\n *\n * const otherValue = createHex('0x010203');\n * console.log(otherValue); // '0x010203'\n * ```\n * @param value - The value to create the hex string from.\n * @returns The created hex string.\n * @throws If the value is not a bytes-like value.\n */\nexport function createHex(value: BytesLike): Hex {\n  if (\n    (value instanceof Uint8Array && value.length === 0) ||\n    (typeof value === 'string' && value.toLowerCase() === '0x')\n  ) {\n    return '0x';\n  }\n\n  try {\n    return create(value, HexCoercer);\n  } catch (error) {\n    if (error instanceof StructError) {\n      throw new Error(\n        `Expected a bytes-like value, got \"${String(error.value)}\".`,\n      );\n    }\n\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n"],"names":["createNumber","createBigInt","createBytes","createHex","NumberLikeStruct","union","number","bigint","string","StrictHexStruct","NumberCoercer","coerce","Number","BigIntCoercer","BigInt","BytesLikeStruct","instance","Uint8Array","BytesCoercer","hexToBytes","HexCoercer","bytesToHex","value","result","create","assert","isFinite","error","StructError","Error","String","toLowerCase","length"],"mappings":";;;;;;;;;;;IA0DgBA,YAAY;eAAZA;;IA0CAC,YAAY;eAAZA;;IAoCAC,WAAW;eAAXA;;IAsCAC,SAAS;eAATA;;;6BApKT;wBAEgB;uBACgB;qBAEP;AAEhC,MAAMC,mBAAmBC,IAAAA,kBAAK,EAAC;IAACC,IAAAA,mBAAM;IAAIC,IAAAA,mBAAM;IAAIC,IAAAA,mBAAM;IAAIC,oBAAe;CAAC;AAC9E,MAAMC,gBAAgBC,IAAAA,mBAAM,EAACL,IAAAA,mBAAM,KAAIF,kBAAkBQ;AACzD,MAAMC,gBAAgBF,IAAAA,mBAAM,EAACJ,IAAAA,mBAAM,KAAIH,kBAAkBU;AAEzD,MAAMC,kBAAkBV,IAAAA,kBAAK,EAAC;IAACI,oBAAe;IAAEO,IAAAA,qBAAQ,EAACC;CAAY;AACrE,MAAMC,eAAeP,IAAAA,mBAAM,EACzBK,IAAAA,qBAAQ,EAACC,aACTZ,IAAAA,kBAAK,EAAC;IAACI,oBAAe;CAAC,GACvBU,iBAAU;AAGZ,MAAMC,aAAaT,IAAAA,mBAAM,EAACF,oBAAe,EAAEO,IAAAA,qBAAQ,EAACC,aAAaI,iBAAU;AA8BpE,SAASrB,aAAasB,KAAiB;IAC5C,IAAI;QACF,MAAMC,SAASC,IAAAA,mBAAM,EAACF,OAAOZ;QAE7Be,IAAAA,cAAM,EACJb,OAAOc,QAAQ,CAACH,SAChB,CAAC,mCAAmC,EAAED,MAAM,EAAE,CAAC;QAGjD,OAAOC;IACT,EAAE,OAAOI,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MAAM,CAAC,mCAAmC,EAAEP,MAAM,EAAE,CAAC;QACjE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAwBO,SAAS1B,aAAaqB,KAAiB;IAC5C,IAAI;QACF,2EAA2E;QAC3E,mDAAmD;QACnD,OAAOE,IAAAA,mBAAM,EAACF,OAAOT;IACvB,EAAE,OAAOc,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,mCAAmC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEjE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAqBO,SAASzB,YAAYoB,KAAgB;IAC1C,IAAI,OAAOA,UAAU,YAAYA,MAAMS,WAAW,OAAO,MAAM;QAC7D,OAAO,IAAId;IACb;IAEA,IAAI;QACF,OAAOO,IAAAA,mBAAM,EAACF,OAAOJ;IACvB,EAAE,OAAOS,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,kCAAkC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF;AAqBO,SAASxB,UAAUmB,KAAgB;IACxC,IACE,AAACA,iBAAiBL,cAAcK,MAAMU,MAAM,KAAK,KAChD,OAAOV,UAAU,YAAYA,MAAMS,WAAW,OAAO,MACtD;QACA,OAAO;IACT;IAEA,IAAI;QACF,OAAOP,IAAAA,mBAAM,EAACF,OAAOF;IACvB,EAAE,OAAOO,OAAO;QACd,IAAIA,iBAAiBC,wBAAW,EAAE;YAChC,MAAM,IAAIC,MACR,CAAC,kCAAkC,EAAEC,OAAOH,MAAML,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMK;IACR;AACF"}

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,37 @@
+"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("./caip-types"), 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 './caip-types';\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;qBACA"}