@metamask/utils 6.2.0 → 7.1.0

package/dist/{number.js → esm/number.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexToBigInt = exports.hexToNumber = exports.bigIntToHex = exports.numberToHex = void 0;
-const assert_1 = require("./assert");
-const hex_1 = require("./hex");
+import { assert } from './assert';
+import { add0x, assertIsHexString } from './hex';
 /**
  * Convert a number to a hexadecimal string. This verifies that the number is a
  * non-negative safe integer.
@@ -19,14 +16,12 @@ const hex_1 = require("./hex");
  * @param value - The number to convert to a hexadecimal string.
  * @returns The hexadecimal string, with the "0x"-prefix.
  * @throws If the number is not a non-negative safe integer.
- */
-const numberToHex = (value) => {
-    (0, assert_1.assert)(typeof value === 'number', 'Value must be a number.');
-    (0, assert_1.assert)(value >= 0, 'Value must be a non-negative number.');
-    (0, assert_1.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToHex` instead.');
-    return (0, hex_1.add0x)(value.toString(16));
+ */ export const numberToHex = (value)=>{
+    assert(typeof value === 'number', 'Value must be a number.');
+    assert(value >= 0, 'Value must be a non-negative number.');
+    assert(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToHex` instead.');
+    return add0x(value.toString(16));
 };
-exports.numberToHex = numberToHex;
 /**
  * Convert a `bigint` to a hexadecimal string. This verifies that the `bigint`
  * is a non-negative integer.
@@ -42,13 +37,11 @@ exports.numberToHex = numberToHex;
  * @param value - The `bigint` to convert to a hexadecimal string.
  * @returns The hexadecimal string, with the "0x"-prefix.
  * @throws If the `bigint` is not a non-negative integer.
- */
-const bigIntToHex = (value) => {
-    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
-    (0, assert_1.assert)(value >= 0, 'Value must be a non-negative bigint.');
-    return (0, hex_1.add0x)(value.toString(16));
+ */ export const bigIntToHex = (value)=>{
+    assert(typeof value === 'bigint', 'Value must be a bigint.');
+    assert(value >= 0, 'Value must be a non-negative bigint.');
+    return add0x(value.toString(16));
 };
-exports.bigIntToHex = bigIntToHex;
 /**
  * Convert a hexadecimal string to a number. This verifies that the string is a
  * valid hex string, and that the resulting number is a safe integer. Both
@@ -67,16 +60,14 @@ exports.bigIntToHex = bigIntToHex;
  * @returns The number.
  * @throws If the value is not a valid hexadecimal string, or if the resulting
  * number is not a safe integer.
- */
-const hexToNumber = (value) => {
-    (0, hex_1.assertIsHexString)(value);
+ */ export const hexToNumber = (value)=>{
+    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_1.assert)(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
+    assert(Number.isSafeInteger(numberValue), 'Value is not a safe integer. Use `hexToBigInt` instead.');
     return numberValue;
 };
-exports.hexToNumber = hexToNumber;
 /**
  * Convert a hexadecimal string to a `bigint`. This verifies that the string is
  * a valid hex string. Both "0x"-prefixed and unprefixed strings are supported.
@@ -92,11 +83,10 @@ exports.hexToNumber = hexToNumber;
  * @param value - The hexadecimal string to convert to a `bigint`.
  * @returns The `bigint`.
  * @throws If the value is not a valid hexadecimal string.
- */
-const hexToBigInt = (value) => {
-    (0, hex_1.assertIsHexString)(value);
+ */ export const hexToBigInt = (value)=>{
+    assertIsHexString(value);
     // The `BigInt` constructor requires the "0x"-prefix to parse a hex string.
-    return BigInt((0, hex_1.add0x)(value));
+    return BigInt(add0x(value));
 };
-exports.hexToBigInt = hexToBigInt;
+
 //# sourceMappingURL=number.js.map

package/dist/esm/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":["assert","add0x","assertIsHexString","numberToHex","value","Number","isSafeInteger","toString","bigIntToHex","hexToNumber","numberValue","parseInt","hexToBigInt","BigInt"],"mappings":"AAAA,SAASA,MAAM,QAAQ,WAAW;AAClC,SAASC,KAAK,EAAEC,iBAAiB,QAAQ,QAAQ;AAEjD;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAMC,cAAc,CAACC;IAC1BJ,OAAO,OAAOI,UAAU,UAAU;IAClCJ,OAAOI,SAAS,GAAG;IACnBJ,OACEK,OAAOC,aAAa,CAACF,QACrB;IAGF,OAAOH,MAAMG,MAAMG,QAAQ,CAAC;AAC9B,EAAE;AAEF;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMC,cAAc,CAACJ;IAC1BJ,OAAO,OAAOI,UAAU,UAAU;IAClCJ,OAAOI,SAAS,GAAG;IAEnB,OAAOH,MAAMG,MAAMG,QAAQ,CAAC;AAC9B,EAAE;AAEF;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAME,cAAc,CAACL;IAC1BF,kBAAkBE;IAElB,2EAA2E;IAC3E,kEAAkE;IAClE,MAAMM,cAAcC,SAASP,OAAO;IAEpCJ,OACEK,OAAOC,aAAa,CAACI,cACrB;IAGF,OAAOA;AACT,EAAE;AAEF;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAME,cAAc,CAACR;IAC1BF,kBAAkBE;IAElB,2EAA2E;IAC3E,OAAOS,OAAOZ,MAAMG;AACtB,EAAE"}

package/dist/esm/opaque.js

@@ -0,0 +1,5 @@
+// We use a symbol property name instead of { _type: Brand }, because that would show up in IDE suggestions,
+// while internal symbols do not.
+export { };
+
+//# sourceMappingURL=opaque.js.map

package/dist/esm/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;AACjC,WAC2E"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/time.js

@@ -0,0 +1,53 @@
+/**
+ * Common duration constants, in milliseconds.
+ */ export 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}".`);
+    }
+};
+/**
+ * Calculates the millisecond value of the specified number of units of time.
+ *
+ * @param count - The number of units of time.
+ * @param duration - The unit of time to count.
+ * @returns The count multiplied by the specified duration.
+ */ export function inMilliseconds(count, duration) {
+    assertIsNonNegativeInteger(count, 'count');
+    return count * duration;
+}
+/**
+ * Gets the milliseconds since a particular Unix epoch timestamp.
+ *
+ * @param timestamp - A Unix millisecond timestamp.
+ * @returns The number of milliseconds elapsed since the specified timestamp.
+ */ export function timeSince(timestamp) {
+    assertIsNonNegativeInteger(timestamp, 'timestamp');
+    return Date.now() - timestamp;
+}
+
+//# sourceMappingURL=time.js.map

package/dist/esm/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":["Duration","Millisecond","Second","Minute","Hour","Day","Week","Year","isNonNegativeInteger","number","Number","isInteger","assertIsNonNegativeInteger","name","Error","inMilliseconds","count","duration","timeSince","timestamp","Date","now"],"mappings":"AAAA;;CAEC,cACM;UAAKA,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;AAEA;;;;;;CAMC,GACD,OAAO,SAASM,eAAeC,KAAa,EAAEC,QAAkB;IAC9DL,2BAA2BI,OAAO;IAClC,OAAOA,QAAQC;AACjB;AAEA;;;;;CAKC,GACD,OAAO,SAASC,UAAUC,SAAiB;IACzCP,2BAA2BO,WAAW;IACtC,OAAOC,KAAKC,GAAG,KAAKF;AACtB"}

package/dist/esm/transaction-types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=transaction-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transaction-types.ts"],"sourcesContent":["import type { Bytes } from './bytes';\nimport type { Hex } from './hex';\n\nexport type Transaction =\n  | LegacyTransaction\n  | EIP2930Transaction\n  | EIP1559Transaction;\n\nexport type SignedTransaction = Transaction & Signature;\n\nexport type Signature = {\n  /**\n   * EC signature parameter\n   * 32 bytes long sequence.\n   */\n  r: Bytes;\n\n  /**\n   * EC signature parameter\n   * Signature proof.\n   * 32 bytes long sequence\n   */\n  s: Bytes;\n\n  /**\n   * Recovery identifier. It can be either 0x1b or 0x1c\n   * 1 byte long sequence\n   */\n  yParity: Bytes;\n};\n\n/**\n * Base Ethereum Transaction\n */\nexport type BaseTransaction = {\n  /**\n   * Sequentially incrementing counter which indicates the transaction\n   * number from the account\n   */\n  nonce: Bytes;\n\n  /**\n   * The address of the sender, that will be signing the transaction\n   */\n  from: Hex | Uint8Array;\n\n  /**\n   * The receiving address.\n   * If an externally-owned account, the transaction will transfer value.\n   * If a contract account, the transaction will execute the contract code.\n   */\n  to: Hex | Uint8Array;\n\n  /**\n   * The amount of Ether sent.\n   */\n  value: Bytes;\n\n  /**\n   * Maximum amount of gas units that this transaction can consume.\n   */\n  gasLimit: Bytes;\n\n  /**\n   * Arbitrary data.\n   */\n  data?: Bytes;\n};\n\n/**\n * Typed Ethereum Transaction\n */\nexport type TypedTransaction = BaseTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: number;\n};\n\n/**\n * Ethereum Legacy Transaction\n * Reference: https://ethereum.org/en/developers/docs/transactions/\n */\nexport type LegacyTransaction = BaseTransaction & {\n  /**\n   * Transaction's gas price.\n   */\n  gasPrice: Bytes | null;\n};\n\n/**\n * EIP-2930 Transaction: Optional Access Lists\n * Reference: https://eips.ethereum.org/EIPS/eip-2930\n */\nexport type EIP2930Transaction = TypedTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: 1;\n\n  /**\n   * Transaction chain ID\n   */\n  chainId: Bytes;\n\n  /**\n   * List of addresses and storage keys that the transaction plans to access\n   */\n  accessList:\n    | { address: Hex; storageKeys: Hex[] }[]\n    | { address: Uint8Array; storageKeys: Uint8Array[] }[];\n};\n\n/**\n * EIP-1559 Transaction: Fee market change for ETH 1.0 chain (Type-2)\n *\n * Reference: https://eips.ethereum.org/EIPS/eip-1559\n */\nexport type EIP1559Transaction = TypedTransaction & {\n  /**\n   * Transaction type.\n   */\n  type: 2;\n\n  /**\n   * Maximum fee to give to the miner\n   */\n  maxPriorityFeePerGas: Bytes;\n\n  /**\n   * Maximum total fee\n   */\n  maxFeePerGas: Bytes;\n};\n"],"names":[],"mappings":"AAAA,WAqIE"}

package/dist/esm/versions.js

@@ -0,0 +1,78 @@
+import { gt as gtSemver, gtr as gtrSemver, satisfies as satisfiesSemver, valid as validSemVerVersion, validRange as validSemVerRange } from 'semver';
+import { is, refine, string } from 'superstruct';
+import { assertStruct } from './assert';
+/**
+ * A struct for validating a version string.
+ */ export const VersionStruct = refine(string(), 'Version', (value)=>{
+    if (validSemVerVersion(value) === null) {
+        return `Expected SemVer version, got "${value}"`;
+    }
+    return true;
+});
+export const VersionRangeStruct = refine(string(), 'Version range', (value)=>{
+    if (validSemVerRange(value) === null) {
+        return `Expected SemVer range, got "${value}"`;
+    }
+    return true;
+});
+/**
+ * Checks whether a SemVer version is valid.
+ *
+ * @param version - A potential version.
+ * @returns `true` if the version is valid, and `false` otherwise.
+ */ export function isValidSemVerVersion(version) {
+    return is(version, VersionStruct);
+}
+/**
+ * Checks whether a SemVer version range is valid.
+ *
+ * @param versionRange - A potential version range.
+ * @returns `true` if the version range is valid, and `false` otherwise.
+ */ export function isValidSemVerRange(versionRange) {
+    return is(versionRange, VersionRangeStruct);
+}
+/**
+ * Asserts that a value is a valid concrete SemVer version.
+ *
+ * @param version - A potential SemVer concrete version.
+ */ export function assertIsSemVerVersion(version) {
+    assertStruct(version, VersionStruct);
+}
+/**
+ * Asserts that a value is a valid SemVer range.
+ *
+ * @param range - A potential SemVer range.
+ */ export function assertIsSemVerRange(range) {
+    assertStruct(range, VersionRangeStruct);
+}
+/**
+ * Checks whether a SemVer version is greater than another.
+ *
+ * @param version1 - The left-hand version.
+ * @param version2 - The right-hand version.
+ * @returns `version1 > version2`.
+ */ export function gtVersion(version1, version2) {
+    return gtSemver(version1, version2);
+}
+/**
+ * Checks whether a SemVer version is greater than all possibilities in a range.
+ *
+ * @param version - A SemvVer version.
+ * @param range - The range to check against.
+ * @returns `version > range`.
+ */ export function gtRange(version, range) {
+    return gtrSemver(version, range);
+}
+/**
+ * Returns whether a SemVer version satisfies a SemVer range.
+ *
+ * @param version - The SemVer version to check.
+ * @param versionRange - The SemVer version range to check against.
+ * @returns Whether the version satisfied the version range.
+ */ export function satisfiesVersionRange(version, versionRange) {
+    return satisfiesSemver(version, versionRange, {
+        includePrerelease: true
+    });
+}
+
+//# sourceMappingURL=versions.js.map

package/dist/esm/versions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/versions.ts"],"sourcesContent":["import {\n  gt as gtSemver,\n  gtr as gtrSemver,\n  satisfies as satisfiesSemver,\n  valid as validSemVerVersion,\n  validRange as validSemVerRange,\n} from 'semver';\nimport type { Struct } from 'superstruct';\nimport { is, refine, string } from 'superstruct';\n\nimport { assertStruct } from './assert';\nimport type { Opaque } from './opaque';\n\n/**\n * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for SemVer ranges.\n *\n * @example Use {@link assertIsSemVerRange} and {@link isValidSemVerRange} to cast to proper type.\n * ```typescript\n * const unsafeRange: string = dataFromUser();\n * assertIsSemVerRange(unsafeRange);\n * unsafeRange\n * // ^? SemVerRange\n * ```\n * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.\n * ```typescript\n * const unsafeRange: string = dataFromUser();\n * unsafeRange as SemVerRange;\n * // ^? SemVerRange\n * ```\n * @see {@link assertIsSemVerRange}\n * @see {@link isValidSemVerRange}\n */\nexport type SemVerRange = Opaque<string, typeof semVerRange>;\ndeclare const semVerRange: unique symbol;\n\n/**\n * {@link https://codemix.com/opaque-types-in-javascript/ Opaque} type for singular SemVer version.\n *\n * @example Use {@link assertIsSemVerVersion} and {@link isValidSemVerVersion} to cast to proper type.\n * ```typescript\n * const unsafeVersion: string = dataFromUser();\n * assertIsSemVerVersion(unsafeRange);\n * unsafeVersion\n * // ^? SemVerVersion\n * ```\n * @example If you know what you're doing and want to side-step type safety, casting from a string works correctly.\n * ```typescript\n * const unsafeVersion: string = dataFromUser();\n * unsafeRange as SemVerVersion;\n * // ^? SemVerVersion\n * ```\n * @see {@link assertIsSemVerVersion}\n * @see {@link isValidSemVerVersion}\n */\nexport type SemVerVersion = Opaque<string, typeof semVerVersion>;\ndeclare const semVerVersion: unique symbol;\n\n/**\n * A struct for validating a version string.\n */\nexport const VersionStruct = refine<SemVerVersion, null>(\n  string() as unknown as Struct<SemVerVersion, null>,\n  'Version',\n  (value) => {\n    if (validSemVerVersion(value) === null) {\n      return `Expected SemVer version, got \"${value}\"`;\n    }\n    return true;\n  },\n);\n\nexport const VersionRangeStruct = refine<SemVerRange, null>(\n  string() as unknown as Struct<SemVerRange, null>,\n  'Version range',\n  (value) => {\n    if (validSemVerRange(value) === null) {\n      return `Expected SemVer range, got \"${value}\"`;\n    }\n    return true;\n  },\n);\n\n/**\n * Checks whether a SemVer version is valid.\n *\n * @param version - A potential version.\n * @returns `true` if the version is valid, and `false` otherwise.\n */\nexport function isValidSemVerVersion(\n  version: unknown,\n): version is SemVerVersion {\n  return is(version, VersionStruct);\n}\n\n/**\n * Checks whether a SemVer version range is valid.\n *\n * @param versionRange - A potential version range.\n * @returns `true` if the version range is valid, and `false` otherwise.\n */\nexport function isValidSemVerRange(\n  versionRange: unknown,\n): versionRange is SemVerRange {\n  return is(versionRange, VersionRangeStruct);\n}\n\n/**\n * Asserts that a value is a valid concrete SemVer version.\n *\n * @param version - A potential SemVer concrete version.\n */\nexport function assertIsSemVerVersion(\n  version: unknown,\n): asserts version is SemVerVersion {\n  assertStruct(version, VersionStruct);\n}\n\n/**\n * Asserts that a value is a valid SemVer range.\n *\n * @param range - A potential SemVer range.\n */\nexport function assertIsSemVerRange(\n  range: unknown,\n): asserts range is SemVerRange {\n  assertStruct(range, VersionRangeStruct);\n}\n\n/**\n * Checks whether a SemVer version is greater than another.\n *\n * @param version1 - The left-hand version.\n * @param version2 - The right-hand version.\n * @returns `version1 > version2`.\n */\nexport function gtVersion(\n  version1: SemVerVersion,\n  version2: SemVerVersion,\n): boolean {\n  return gtSemver(version1, version2);\n}\n\n/**\n * Checks whether a SemVer version is greater than all possibilities in a range.\n *\n * @param version - A SemvVer version.\n * @param range - The range to check against.\n * @returns `version > range`.\n */\nexport function gtRange(version: SemVerVersion, range: SemVerRange): boolean {\n  return gtrSemver(version, range);\n}\n\n/**\n * Returns whether a SemVer version satisfies a SemVer range.\n *\n * @param version - The SemVer version to check.\n * @param versionRange - The SemVer version range to check against.\n * @returns Whether the version satisfied the version range.\n */\nexport function satisfiesVersionRange(\n  version: SemVerVersion,\n  versionRange: SemVerRange,\n): boolean {\n  return satisfiesSemver(version, versionRange, {\n    includePrerelease: true,\n  });\n}\n"],"names":["gt","gtSemver","gtr","gtrSemver","satisfies","satisfiesSemver","valid","validSemVerVersion","validRange","validSemVerRange","is","refine","string","assertStruct","VersionStruct","value","VersionRangeStruct","isValidSemVerVersion","version","isValidSemVerRange","versionRange","assertIsSemVerVersion","assertIsSemVerRange","range","gtVersion","version1","version2","gtRange","satisfiesVersionRange","includePrerelease"],"mappings":"AAAA,SACEA,MAAMC,QAAQ,EACdC,OAAOC,SAAS,EAChBC,aAAaC,eAAe,EAC5BC,SAASC,kBAAkB,EAC3BC,cAAcC,gBAAgB,QACzB,SAAS;AAEhB,SAASC,EAAE,EAAEC,MAAM,EAAEC,MAAM,QAAQ,cAAc;AAEjD,SAASC,YAAY,QAAQ,WAAW;AA+CxC;;CAEC,GACD,OAAO,MAAMC,gBAAgBH,OAC3BC,UACA,WACA,CAACG;IACC,IAAIR,mBAAmBQ,WAAW,MAAM;QACtC,OAAO,CAAC,8BAA8B,EAAEA,MAAM,CAAC,CAAC;IAClD;IACA,OAAO;AACT,GACA;AAEF,OAAO,MAAMC,qBAAqBL,OAChCC,UACA,iBACA,CAACG;IACC,IAAIN,iBAAiBM,WAAW,MAAM;QACpC,OAAO,CAAC,4BAA4B,EAAEA,MAAM,CAAC,CAAC;IAChD;IACA,OAAO;AACT,GACA;AAEF;;;;;CAKC,GACD,OAAO,SAASE,qBACdC,OAAgB;IAEhB,OAAOR,GAAGQ,SAASJ;AACrB;AAEA;;;;;CAKC,GACD,OAAO,SAASK,mBACdC,YAAqB;IAErB,OAAOV,GAAGU,cAAcJ;AAC1B;AAEA;;;;CAIC,GACD,OAAO,SAASK,sBACdH,OAAgB;IAEhBL,aAAaK,SAASJ;AACxB;AAEA;;;;CAIC,GACD,OAAO,SAASQ,oBACdC,KAAc;IAEdV,aAAaU,OAAOP;AACtB;AAEA;;;;;;CAMC,GACD,OAAO,SAASQ,UACdC,QAAuB,EACvBC,QAAuB;IAEvB,OAAOzB,SAASwB,UAAUC;AAC5B;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,QAAQT,OAAsB,EAAEK,KAAkB;IAChE,OAAOpB,UAAUe,SAASK;AAC5B;AAEA;;;;;;CAMC,GACD,OAAO,SAASK,sBACdV,OAAsB,EACtBE,YAAyB;IAEzB,OAAOf,gBAAgBa,SAASE,cAAc;QAC5CS,mBAAmB;IACrB;AACF"}

package/dist/{assert.d.ts → types/assert.d.ts}

@@ -1,4 +1,4 @@
-import { Struct } from 'superstruct';
+import type { Struct } from 'superstruct';
 export declare type AssertionErrorConstructor = (new (args: {
     message: string;
 }) => Error) | ((args: {
@@ -37,7 +37,7 @@ export declare function assert(value: any, message?: string | Error, ErrorWrappe
  * Defaults to {@link AssertionError}.
  * @throws If the value is not valid.
  */
-export declare function assertStruct<T, S>(value: unknown, struct: Struct<T, S>, errorPrefix?: string, ErrorWrapper?: AssertionErrorConstructor): asserts value is T;
+export declare function assertStruct<Type, Schema>(value: unknown, struct: Struct<Type, Schema>, errorPrefix?: string, ErrorWrapper?: AssertionErrorConstructor): asserts value is Type;
 /**
  * Use in the default case of a switch that you want to be fully exhaustive.
  * Using this function forces the compiler to enforce exhaustivity during
@@ -58,3 +58,4 @@ export declare function assertStruct<T, S>(value: unknown, struct: Struct<T, S>,
  * @param _object - The object on which the switch is being operated.
  */
 export declare function assertExhaustive(_object: never): never;
+//# sourceMappingURL=assert.d.ts.map

package/dist/types/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C,oBAAY,yBAAyB,GACjC,CAAC,KAAK,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,KAAK,CAAC,GAC1C,CAAC,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,KAAK,CAAC,CAAC;AAiE3C;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,mBAAmB;gBAEpB,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;CAGzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CACpB,KAAK,EAAE,GAAG,EACV,OAAO,GAAE,MAAM,GAAG,KAA2B,EAE7C,YAAY,GAAE,yBAA0C,GACvD,OAAO,CAAC,KAAK,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EACvC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAC5B,WAAW,SAAqB,EAEhC,YAAY,GAAE,yBAA0C,GACvD,OAAO,CAAC,KAAK,IAAI,IAAI,CAMvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,KAAK,GAAG,KAAK,CAItD"}

package/dist/{base64.d.ts → types/base64.d.ts}

@@ -1,4 +1,4 @@
-import { Struct } from 'superstruct';
+import type { Struct } from 'superstruct';
 export declare type Base64Options = {
     /**
      * Is the `=` padding at the end required or not.
@@ -21,4 +21,5 @@ export declare type Base64Options = {
  * @param options - Optional options to specialize base64 validation. See {@link Base64Options} documentation.
  * @returns A superstruct validating base64.
  */
-export declare const base64: <T extends string, S>(struct: Struct<T, S>, options?: Base64Options) => Struct<T, S>;
+export declare const base64: <Type extends string, Schema>(struct: Struct<Type, Schema>, options?: Base64Options) => Struct<Type, Schema>;
+//# sourceMappingURL=base64.d.ts.map

package/dist/types/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/base64.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAK1C,oBAAY,aAAa,GAAG;IAC1B;;;;OAIG;IAEH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;CACvC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,wEAER,aAAa,yBA2BvB,CAAC"}

package/dist/{bytes.d.ts → types/bytes.d.ts}

@@ -1,4 +1,4 @@
-import { Hex } from './hex';
+import type { Hex } from './hex';
 export declare type Bytes = bigint | number | string | Uint8Array;
 /**
  * Check if a value is a `Uint8Array`.
@@ -166,3 +166,4 @@ export declare function concatBytes(values: Bytes[]): Uint8Array;
  * @returns The {@link DataView}.
  */
 export declare function createDataView(bytes: Uint8Array): DataView;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/types/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/bytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAUjC,oBAAY,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAwC1D;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,CAgBjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAU7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAoCpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAMvD;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,GACjB,UAAU,CAqBZ;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAUvD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAIvD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAsBrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAqBvD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAe1D"}

package/dist/types/caip-types.d.ts

@@ -0,0 +1,93 @@
+import type { Infer } from 'superstruct';
+export declare const CAIP_CHAIN_ID_REGEX: RegExp;
+export declare const CAIP_NAMESPACE_REGEX: RegExp;
+export declare const CAIP_REFERENCE_REGEX: RegExp;
+export declare const CAIP_ACCOUNT_ID_REGEX: RegExp;
+export declare const CAIP_ACCOUNT_ADDRESS_REGEX: RegExp;
+/**
+ * A CAIP-2 chain ID, i.e., a human-readable namespace and reference.
+ */
+export declare const CaipChainIdStruct: import("superstruct").Struct<string, null>;
+export declare type CaipChainId = `${string}:${string}`;
+/**
+ * A CAIP-2 namespace, i.e., the first part of a CAIP chain ID.
+ */
+export declare const CaipNamespaceStruct: import("superstruct").Struct<string, null>;
+export declare type CaipNamespace = Infer<typeof CaipNamespaceStruct>;
+/**
+ * A CAIP-2 reference, i.e., the second part of a CAIP chain ID.
+ */
+export declare const CaipReferenceStruct: import("superstruct").Struct<string, null>;
+export declare type CaipReference = Infer<typeof CaipReferenceStruct>;
+/**
+ * A CAIP-10 account ID, i.e., a human-readable namespace, reference, and account address.
+ */
+export declare const CaipAccountIdStruct: import("superstruct").Struct<string, null>;
+export declare type CaipAccountId = `${string}:${string}:${string}`;
+/**
+ * A CAIP-10 account address, i.e., the third part of the CAIP account ID.
+ */
+export declare const CaipAccountAddressStruct: import("superstruct").Struct<string, null>;
+export declare type CaipAccountAddress = Infer<typeof CaipAccountAddressStruct>;
+/**
+ * Check if the given value is a {@link CaipChainId}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipChainId}.
+ */
+export declare function isCaipChainId(value: unknown): value is CaipChainId;
+/**
+ * Check if the given value is a {@link CaipNamespace}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipNamespace}.
+ */
+export declare function isCaipNamespace(value: unknown): value is CaipNamespace;
+/**
+ * Check if the given value is a {@link CaipReference}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipReference}.
+ */
+export declare function isCaipReference(value: unknown): value is CaipReference;
+/**
+ * Check if the given value is a {@link CaipAccountId}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipAccountId}.
+ */
+export declare function isCaipAccountId(value: unknown): value is CaipAccountId;
+/**
+ * Check if a value is a {@link CaipAccountAddress}.
+ *
+ * @param value - The value to validate.
+ * @returns True if the value is a valid {@link CaipAccountAddress}.
+ */
+export declare function isCaipAccountAddress(value: unknown): value is CaipAccountAddress;
+/**
+ * Parse a CAIP-2 chain ID to an object containing the namespace and reference.
+ * This validates the CAIP-2 chain ID before parsing it.
+ *
+ * @param caipChainId - The CAIP-2 chain ID to validate and parse.
+ * @returns The parsed CAIP-2 chain ID.
+ */
+export declare function parseCaipChainId(caipChainId: CaipChainId): {
+    namespace: CaipNamespace;
+    reference: CaipReference;
+};
+/**
+ * Parse an CAIP-10 account ID to an object containing the chain ID, parsed chain ID, and account address.
+ * This validates the CAIP-10 account ID before parsing it.
+ *
+ * @param caipAccountId - The CAIP-10 account ID to validate and parse.
+ * @returns The parsed CAIP-10 account ID.
+ */
+export declare function parseCaipAccountId(caipAccountId: CaipAccountId): {
+    address: CaipAccountAddress;
+    chainId: CaipChainId;
+    chain: {
+        namespace: CaipNamespace;
+        reference: CaipReference;
+    };
+};
+//# sourceMappingURL=caip-types.d.ts.map

package/dist/types/caip-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caip-types.d.ts","sourceRoot":"","sources":["../../src/caip-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,eAAO,MAAM,mBAAmB,QACqC,CAAC;AAEtE,eAAO,MAAM,oBAAoB,QAAsB,CAAC;AAExD,eAAO,MAAM,oBAAoB,QAA2B,CAAC;AAE7D,eAAO,MAAM,qBAAqB,QACwF,CAAC;AAE3H,eAAO,MAAM,0BAA0B,QAA6B,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,iBAAiB,4CAAyC,CAAC;AACxE,oBAAY,WAAW,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,mBAAmB,4CAA0C,CAAC;AAC3E,oBAAY,aAAa,GAAG,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,mBAAmB,4CAA0C,CAAC;AAC3E,oBAAY,aAAa,GAAG,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,mBAAmB,4CAA2C,CAAC;AAC5E,oBAAY,aAAa,GAAG,GAAG,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,wBAAwB,4CAGpC,CAAC;AACF,oBAAY,kBAAkB,GAAG,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAE7B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG;IAC1D,SAAS,EAAE,aAAa,CAAC;IACzB,SAAS,EAAE,aAAa,CAAC;CAC1B,CAUA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,aAAa,GAAG;IAChE,OAAO,EAAE,kBAAkB,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE;QAAE,SAAS,EAAE,aAAa,CAAC;QAAC,SAAS,EAAE,aAAa,CAAA;KAAE,CAAC;CAC/D,CAcA"}

package/dist/types/caip-types.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=caip-types.test-d.d.ts.map

package/dist/types/caip-types.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caip-types.test-d.d.ts","sourceRoot":"","sources":["../../src/caip-types.test-d.ts"],"names":[],"mappings":""}

package/dist/{checksum.d.ts → types/checksum.d.ts}

@@ -1 +1,2 @@
 export declare const ChecksumStruct: import("superstruct").Struct<string, null>;
+//# sourceMappingURL=checksum.d.ts.map

package/dist/types/checksum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/checksum.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,4CAI1B,CAAC"}

package/dist/{coercers.d.ts → types/coercers.d.ts}

@@ -1,5 +1,5 @@
-import { Infer } from 'superstruct';
-import { Hex } from './hex';
+import type { Infer } from 'superstruct';
+import type { Hex } from './hex';
 declare const NumberLikeStruct: import("superstruct").Struct<string | number | bigint, null>;
 declare const BytesLikeStruct: import("superstruct").Struct<Uint8Array | `0x${string}`, null>;
 export declare type NumberLike = Infer<typeof NumberLikeStruct>;
@@ -94,3 +94,4 @@ export declare function createBytes(value: BytesLike): Uint8Array;
  */
 export declare function createHex(value: BytesLike): Hex;
 export {};
+//# sourceMappingURL=coercers.d.ts.map

package/dist/types/coercers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coercers.d.ts","sourceRoot":"","sources":["../../src/coercers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAczC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAGjC,QAAA,MAAM,gBAAgB,8DAAyD,CAAC;AAIhF,QAAA,MAAM,eAAe,gEAAiD,CAAC;AASvE,oBAAY,UAAU,GAAG,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACxD,oBAAY,SAAS,GAAG,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAkBtD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAetD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAiBxD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,GAAG,CAoB/C"}

package/dist/{collections.d.ts → types/collections.d.ts}

@@ -36,3 +36,4 @@ declare class FrozenSet<Value> implements ReadonlySet<Value> {
     toString(): string;
 }
 export { FrozenMap, FrozenSet };
+//# sourceMappingURL=collections.d.ts.map

package/dist/types/collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/collections.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAM,SAAS,CAAC,GAAG,EAAE,KAAK,CAAE,YAAW,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC;;IAG5D,IAAW,IAAI,WAEd;IAEM,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAIZ,OAAO,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,IAAI;IAKxD,OAAO;IAIP,OAAO,CACZ,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,GAAG,GACZ,IAAI;IAQA,GAAG,CAAC,GAAG,EAAE,GAAG;IAIZ,GAAG,CAAC,GAAG,EAAE,GAAG;IAIZ,IAAI;IAIJ,MAAM;IAIN,QAAQ,IAAI,MAAM;CAS1B;AAED;;;;;GAKG;AACH,cAAM,SAAS,CAAC,KAAK,CAAE,YAAW,WAAW,CAAC,KAAK,CAAC;;IAGlD,IAAW,IAAI,WAEd;IAEM,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAIZ,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,GAAG,IAAI;IAKrC,OAAO;IAIP,OAAO,CACZ,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,KAAK,IAAI,EAC5D,OAAO,CAAC,EAAE,GAAG,GACZ,IAAI;IAQA,GAAG,CAAC,KAAK,EAAE,KAAK;IAIhB,IAAI;IAIJ,MAAM;IAIN,QAAQ,IAAI,MAAM;CAO1B;AAQD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC"}

package/dist/{encryption-types.d.ts → types/encryption-types.d.ts}

@@ -4,3 +4,4 @@ export declare type Eip1024EncryptedData = {
     ephemPublicKey: string;
     ciphertext: string;
 };
+//# sourceMappingURL=encryption-types.d.ts.map

package/dist/types/encryption-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption-types.d.ts","sourceRoot":"","sources":["../../src/encryption-types.ts"],"names":[],"mappings":"AAAA,oBAAY,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/{hex.d.ts → types/hex.d.ts}

@@ -1,4 +1,4 @@
-import { Struct } from 'superstruct';
+import type { Struct } from 'superstruct';
 export declare type Hex = `0x${string}`;
 export declare const HexStruct: Struct<string, null>;
 export declare const StrictHexStruct: Struct<`0x${string}`, null>;
@@ -74,3 +74,4 @@ export declare function add0x(hexadecimal: string): Hex;
  * @returns The un-prefixed hexadecimal string.
  */
 export declare function remove0x(hexadecimal: string): string;
+//# sourceMappingURL=hex.d.ts.map

package/dist/types/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../src/hex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAM1C,oBAAY,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAEhC,eAAO,MAAM,SAAS,sBAA4C,CAAC;AACnE,eAAO,MAAM,eAAe,6BAG3B,CAAC;AACF,eAAO,MAAM,gBAAgB,6BAGP,CAAC;AACvB,eAAO,MAAM,wBAAwB,6BAGf,CAAC;AAEvB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,GAAG,CAK5E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,GAAG,WAKrD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,GAAG,UAc9C;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,GAAG,WAM3D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAU9C;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMpD"}

package/dist/types/hex.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hex.test-d.d.ts.map

package/dist/types/hex.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.test-d.d.ts","sourceRoot":"","sources":["../../src/hex.test-d.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+export * from './assert';
+export * from './base64';
+export * from './bytes';
+export * from './caip-types';
+export * from './checksum';
+export * from './coercers';
+export * from './collections';
+export * from './encryption-types';
+export * from './hex';
+export * from './json';
+export * from './keyring';
+export * from './logging';
+export * from './misc';
+export * from './number';
+export * from './opaque';
+export * from './time';
+export * from './transaction-types';
+export * from './versions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC"}

package/dist/{json.d.ts → types/json.d.ts}

@@ -1,5 +1,5 @@
-import { Infer, Struct } from 'superstruct';
-import { AssertionErrorConstructor } from './assert';
+import type { Infer, Struct } from 'superstruct';
+import type { AssertionErrorConstructor } from './assert';
 /**
  * Any JSON-compatible value.
  */
@@ -345,3 +345,4 @@ declare type JsonRpcValidatorOptions = {
  */
 export declare function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions): (id: unknown) => id is string | number | null;
 export {};
+//# sourceMappingURL=json.d.ts.map

package/dist/types/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/json.ts"],"names":[],"mappings":"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"}

package/dist/types/json.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.test-d.d.ts.map

package/dist/types/json.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.test-d.d.ts","sourceRoot":"","sources":["../../src/json.test-d.ts"],"names":[],"mappings":""}

package/dist/{keyring.d.ts → types/keyring.d.ts}

@@ -1,7 +1,7 @@
 import type { TypedTransaction, TxData } from '@ethereumjs/tx';
 import type { Eip1024EncryptedData } from './encryption-types';
-import { Hex } from './hex';
-import { Json } from './json';
+import type { Hex } from './hex';
+import type { Json } from './json';
 /**
  * A Keyring class.
  *
@@ -221,3 +221,4 @@ export declare type Keyring<State extends Json> = {
      */
     destroy?(): Promise<void>;
 };
+//# sourceMappingURL=keyring.d.ts.map

package/dist/types/keyring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring.d.ts","sourceRoot":"","sources":["../../src/keyring.ts"],"names":[],"mappings":"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"}

package/dist/{logging.d.ts → types/logging.d.ts}

@@ -1,4 +1,4 @@
-import { Debugger } from 'debug';
+import type { Debugger } from 'debug';
 /**
  * Creates a logger via the `debug` library whose log messages will be tagged
  * using the name of your project. By default, such messages will be
@@ -27,3 +27,4 @@ export declare function createProjectLogger(projectName: string): Debugger;
  * @returns An instance of `debug`.
  */
 export declare function createModuleLogger(projectLogger: Debugger, moduleName: string): Debugger;
+//# sourceMappingURL=logging.d.ts.map

package/dist/types/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAKtC;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAEjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,QAAQ,EACvB,UAAU,EAAE,MAAM,GACjB,QAAQ,CAEV"}