@metamask/utils 6.2.0 → 7.1.0

package/dist/esm/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bytes.ts"],"sourcesContent":["import { assert } from './assert';\nimport type { Hex } from './hex';\nimport { add0x, assertIsHexString, remove0x } from './hex';\n\n// '0'.charCodeAt(0) === 48\nconst HEX_MINIMUM_NUMBER_CHARACTER = 48;\n\n// '9'.charCodeAt(0) === 57\nconst HEX_MAXIMUM_NUMBER_CHARACTER = 58;\nconst HEX_CHARACTER_OFFSET = 87;\n\nexport type Bytes = bigint | number | string | Uint8Array;\n\n/**\n * Memoized function that returns an array to be used as a lookup table for\n * converting bytes to hexadecimal values.\n *\n * The array is created lazily and then cached for future use. The benefit of\n * this approach is that the performance of converting bytes to hex is much\n * better than if we were to call `toString(16)` on each byte.\n *\n * The downside is that the array is created once and then never garbage\n * collected. This is not a problem in practice because the array is only 256\n * elements long.\n *\n * @returns A function that returns the lookup table.\n */\nfunction getPrecomputedHexValuesBuilder(): () => string[] {\n  // To avoid issues with tree shaking, we need to use a function to return the\n  // array. This is because the array is only used in the `bytesToHex` function\n  // and if we were to use a global variable, the array might be removed by the\n  // tree shaker.\n  const lookupTable: string[] = [];\n\n  return () => {\n    if (lookupTable.length === 0) {\n      for (let i = 0; i < 256; i++) {\n        lookupTable.push(i.toString(16).padStart(2, '0'));\n      }\n    }\n\n    return lookupTable;\n  };\n}\n\n/**\n * Function implementation of the {@link getPrecomputedHexValuesBuilder}\n * function.\n */\nconst getPrecomputedHexValues = getPrecomputedHexValuesBuilder();\n\n/**\n * Check if a value is a `Uint8Array`.\n *\n * @param value - The value to check.\n * @returns Whether the value is a `Uint8Array`.\n */\nexport function isBytes(value: unknown): value is Uint8Array {\n  return value instanceof Uint8Array;\n}\n\n/**\n * Assert that a value is a `Uint8Array`.\n *\n * @param value - The value to check.\n * @throws If the value is not a `Uint8Array`.\n */\nexport function assertIsBytes(value: unknown): asserts value is Uint8Array {\n  assert(isBytes(value), 'Value must be a Uint8Array.');\n}\n\n/**\n * Convert a `Uint8Array` to a hexadecimal string.\n *\n * @param bytes - The bytes to convert to a hexadecimal string.\n * @returns The hexadecimal string.\n */\nexport function bytesToHex(bytes: Uint8Array): Hex {\n  assertIsBytes(bytes);\n\n  if (bytes.length === 0) {\n    return '0x';\n  }\n\n  const lookupTable = getPrecomputedHexValues();\n  const hexadecimal = new Array(bytes.length);\n\n  for (let i = 0; i < bytes.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    hexadecimal[i] = lookupTable[bytes[i]!];\n  }\n\n  return add0x(hexadecimal.join(''));\n}\n\n/**\n * Convert a `Uint8Array` to a `bigint`.\n *\n * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.\n * To convert a two's complement encoded `Uint8Array` to a `bigint`, use\n * {@link bytesToSignedBigInt}.\n *\n * @param bytes - The bytes to convert to a `bigint`.\n * @returns The `bigint`.\n */\nexport function bytesToBigInt(bytes: Uint8Array): bigint {\n  assertIsBytes(bytes);\n\n  const hexadecimal = bytesToHex(bytes);\n  return BigInt(hexadecimal);\n}\n\n/**\n * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are\n * encoded in two's complement.\n *\n * To convert a `Uint8Array` to an unsigned `bigint` instead, use\n * {@link bytesToBigInt}.\n *\n * @see https://en.wikipedia.org/wiki/Two%27s_complement\n * @param bytes - The bytes to convert to a signed `bigint`.\n * @returns The signed `bigint`.\n */\nexport function bytesToSignedBigInt(bytes: Uint8Array): bigint {\n  assertIsBytes(bytes);\n\n  let value = BigInt(0);\n  for (const byte of bytes) {\n    // eslint-disable-next-line no-bitwise\n    value = (value << BigInt(8)) + BigInt(byte);\n  }\n\n  return BigInt.asIntN(bytes.length * 8, value);\n}\n\n/**\n * Convert a `Uint8Array` to a `number`.\n *\n * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.\n *\n * @param bytes - The bytes to convert to a number.\n * @returns The number.\n * @throws If the resulting number is not a safe integer.\n */\nexport function bytesToNumber(bytes: Uint8Array): number {\n  assertIsBytes(bytes);\n\n  const bigint = bytesToBigInt(bytes);\n\n  assert(\n    bigint <= BigInt(Number.MAX_SAFE_INTEGER),\n    'Number is not a safe integer. Use `bytesToBigInt` instead.',\n  );\n\n  return Number(bigint);\n}\n\n/**\n * Convert a UTF-8 encoded `Uint8Array` to a `string`.\n *\n * @param bytes - The bytes to convert to a string.\n * @returns The string.\n */\nexport function bytesToString(bytes: Uint8Array): string {\n  assertIsBytes(bytes);\n\n  return new TextDecoder().decode(bytes);\n}\n\n/**\n * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be\n * prefixed with `0x`. It accepts even and odd length strings.\n *\n * If the value is \"0x\", an empty `Uint8Array` is returned.\n *\n * @param value - The hexadecimal string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function hexToBytes(value: string): Uint8Array {\n  // \"0x\" is often used as empty byte array.\n  if (value?.toLowerCase?.() === '0x') {\n    return new Uint8Array();\n  }\n\n  assertIsHexString(value);\n\n  // Remove the `0x` prefix if it exists, and pad the string to have an even\n  // number of characters.\n  const strippedValue = remove0x(value).toLowerCase();\n  const normalizedValue =\n    strippedValue.length % 2 === 0 ? strippedValue : `0${strippedValue}`;\n  const bytes = new Uint8Array(normalizedValue.length / 2);\n\n  for (let i = 0; i < bytes.length; i++) {\n    // While this is not the prettiest way to convert a hexadecimal string to a\n    // `Uint8Array`, it is a lot faster than using `parseInt` to convert each\n    // character.\n    const c1 = normalizedValue.charCodeAt(i * 2);\n    const c2 = normalizedValue.charCodeAt(i * 2 + 1);\n    const n1 =\n      c1 -\n      (c1 < HEX_MAXIMUM_NUMBER_CHARACTER\n        ? HEX_MINIMUM_NUMBER_CHARACTER\n        : HEX_CHARACTER_OFFSET);\n    const n2 =\n      c2 -\n      (c2 < HEX_MAXIMUM_NUMBER_CHARACTER\n        ? HEX_MINIMUM_NUMBER_CHARACTER\n        : HEX_CHARACTER_OFFSET);\n\n    bytes[i] = n1 * 16 + n2;\n  }\n\n  return bytes;\n}\n\n/**\n * Convert a `bigint` to a `Uint8Array`.\n *\n * This assumes that the `bigint` is an unsigned integer. To convert a signed\n * `bigint` instead, use {@link signedBigIntToBytes}.\n *\n * @param value - The bigint to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function bigIntToBytes(value: bigint): Uint8Array {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= BigInt(0), 'Value must be a non-negative bigint.');\n\n  const hexadecimal = value.toString(16);\n  return hexToBytes(hexadecimal);\n}\n\n/**\n * Check if a `bigint` fits in a certain number of bytes.\n *\n * @param value - The `bigint` to check.\n * @param bytes - The number of bytes.\n * @returns Whether the `bigint` fits in the number of bytes.\n */\nfunction bigIntFits(value: bigint, bytes: number): boolean {\n  assert(bytes > 0);\n\n  /* eslint-disable no-bitwise */\n  const mask = value >> BigInt(31);\n  return !(((~value & mask) + (value & ~mask)) >> BigInt(bytes * 8 + ~0));\n  /* eslint-enable no-bitwise */\n}\n\n/**\n * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement\n * encoding to represent negative numbers.\n *\n * To convert an unsigned `bigint` to a `Uint8Array` instead, use\n * {@link bigIntToBytes}.\n *\n * @see https://en.wikipedia.org/wiki/Two%27s_complement\n * @param value - The number to convert to bytes.\n * @param byteLength - The length of the resulting `Uint8Array`. If the number\n * is larger than the maximum value that can be represented by the given length,\n * an error is thrown.\n * @returns The bytes as `Uint8Array`.\n */\nexport function signedBigIntToBytes(\n  value: bigint,\n  byteLength: number,\n): Uint8Array {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(typeof byteLength === 'number', 'Byte length must be a number.');\n  assert(byteLength > 0, 'Byte length must be greater than 0.');\n  assert(\n    bigIntFits(value, byteLength),\n    'Byte length is too small to represent the given value.',\n  );\n\n  // ESLint doesn't like mutating function parameters, so to avoid having to\n  // disable the rule, we create a new variable.\n  let numberValue = value;\n  const bytes = new Uint8Array(byteLength);\n\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number(BigInt.asUintN(8, numberValue));\n    // eslint-disable-next-line no-bitwise\n    numberValue >>= BigInt(8);\n  }\n\n  return bytes.reverse();\n}\n\n/**\n * Convert a `number` to a `Uint8Array`.\n *\n * @param value - The number to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n * @throws If the number is not a safe integer.\n */\nexport function numberToBytes(value: number): Uint8Array {\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 `bigIntToBytes` instead.',\n  );\n\n  const hexadecimal = value.toString(16);\n  return hexToBytes(hexadecimal);\n}\n\n/**\n * Convert a `string` to a UTF-8 encoded `Uint8Array`.\n *\n * @param value - The string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function stringToBytes(value: string): Uint8Array {\n  assert(typeof value === 'string', 'Value must be a string.');\n\n  return new TextEncoder().encode(value);\n}\n\n/**\n * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,\n * a `bigint`, a `number`, or a `string`.\n *\n * This will attempt to guess the type of the value based on its type and\n * contents. For more control over the conversion, use the more specific\n * conversion functions, such as {@link hexToBytes} or {@link stringToBytes}.\n *\n * If the value is a `string`, and it is prefixed with `0x`, it will be\n * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a\n * UTF-8 string. To convert a hexadecimal string to bytes without interpreting\n * it as a UTF-8 string, use {@link hexToBytes} instead.\n *\n * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed\n * `bigint` to bytes, use {@link signedBigIntToBytes} instead.\n *\n * If the value is a `Uint8Array`, it will be returned as-is.\n *\n * @param value - The value to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function valueToBytes(value: Bytes): Uint8Array {\n  if (typeof value === 'bigint') {\n    return bigIntToBytes(value);\n  }\n\n  if (typeof value === 'number') {\n    return numberToBytes(value);\n  }\n\n  if (typeof value === 'string') {\n    if (value.startsWith('0x')) {\n      return hexToBytes(value);\n    }\n\n    return stringToBytes(value);\n  }\n\n  if (isBytes(value)) {\n    return value;\n  }\n\n  throw new TypeError(`Unsupported value type: \"${typeof value}\".`);\n}\n\n/**\n * Concatenate multiple byte-like values into a single `Uint8Array`. The values\n * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses\n * {@link valueToBytes} under the hood to convert each value to bytes. Refer to\n * the documentation of that function for more information.\n *\n * @param values - The values to concatenate.\n * @returns The concatenated bytes as `Uint8Array`.\n */\nexport function concatBytes(values: Bytes[]): Uint8Array {\n  const normalizedValues = new Array(values.length);\n  let byteLength = 0;\n\n  for (let i = 0; i < values.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const value = valueToBytes(values[i]!);\n\n    normalizedValues[i] = value;\n    byteLength += value.length;\n  }\n\n  const bytes = new Uint8Array(byteLength);\n  for (let i = 0, offset = 0; i < normalizedValues.length; i++) {\n    // While we could simply spread the values into an array and use\n    // `Uint8Array.from`, that is a lot slower than using `Uint8Array.set`.\n    bytes.set(normalizedValues[i], offset);\n    offset += normalizedValues[i].length;\n  }\n\n  return bytes;\n}\n\n/**\n * Create a {@link DataView} from a {@link Uint8Array}. This is a convenience\n * function that avoids having to create a {@link DataView} manually, which\n * requires passing the `byteOffset` and `byteLength` parameters every time.\n *\n * Not passing the `byteOffset` and `byteLength` parameters can result in\n * unexpected behavior when the {@link Uint8Array} is a view of a larger\n * {@link ArrayBuffer}, e.g., when using {@link Uint8Array.subarray}.\n *\n * This function also supports Node.js {@link Buffer}s.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([1, 2, 3]);\n *\n * // This is equivalent to:\n * // const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n * const dataView = createDataView(bytes);\n * ```\n * @param bytes - The bytes to create the {@link DataView} from.\n * @returns The {@link DataView}.\n */\nexport function createDataView(bytes: Uint8Array): DataView {\n  // To maintain compatibility with Node.js, we need to check if the bytes are\n  // a Buffer. If so, we need to slice the buffer to get the underlying\n  // ArrayBuffer.\n  // eslint-disable-next-line no-restricted-globals\n  if (typeof Buffer !== 'undefined' && bytes instanceof Buffer) {\n    const buffer = bytes.buffer.slice(\n      bytes.byteOffset,\n      bytes.byteOffset + bytes.byteLength,\n    );\n\n    return new DataView(buffer);\n  }\n\n  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n}\n"],"names":["assert","add0x","assertIsHexString","remove0x","HEX_MINIMUM_NUMBER_CHARACTER","HEX_MAXIMUM_NUMBER_CHARACTER","HEX_CHARACTER_OFFSET","getPrecomputedHexValuesBuilder","lookupTable","length","i","push","toString","padStart","getPrecomputedHexValues","isBytes","value","Uint8Array","assertIsBytes","bytesToHex","bytes","hexadecimal","Array","join","bytesToBigInt","BigInt","bytesToSignedBigInt","byte","asIntN","bytesToNumber","bigint","Number","MAX_SAFE_INTEGER","bytesToString","TextDecoder","decode","hexToBytes","toLowerCase","strippedValue","normalizedValue","c1","charCodeAt","c2","n1","n2","bigIntToBytes","bigIntFits","mask","signedBigIntToBytes","byteLength","numberValue","asUintN","reverse","numberToBytes","isSafeInteger","stringToBytes","TextEncoder","encode","valueToBytes","startsWith","TypeError","concatBytes","values","normalizedValues","offset","set","createDataView","Buffer","buffer","slice","byteOffset","DataView"],"mappings":"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"}

package/dist/esm/caip-types.js

@@ -0,0 +1,99 @@
+import { is, pattern, string } from 'superstruct';
+export const CAIP_CHAIN_ID_REGEX = RegExp("^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})$", "u");
+export const CAIP_NAMESPACE_REGEX = /^[-a-z0-9]{3,8}$/u;
+export const CAIP_REFERENCE_REGEX = /^[-_a-zA-Z0-9]{1,32}$/u;
+export const CAIP_ACCOUNT_ID_REGEX = RegExp("^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})):(?<accountAddress>[-.%a-zA-Z0-9]{1,128})$", "u");
+export const CAIP_ACCOUNT_ADDRESS_REGEX = /^[-.%a-zA-Z0-9]{1,128}$/u;
+/**
+ * A CAIP-2 chain ID, i.e., a human-readable namespace and reference.
+ */ export const CaipChainIdStruct = pattern(string(), CAIP_CHAIN_ID_REGEX);
+/**
+ * A CAIP-2 namespace, i.e., the first part of a CAIP chain ID.
+ */ export const CaipNamespaceStruct = pattern(string(), CAIP_NAMESPACE_REGEX);
+/**
+ * A CAIP-2 reference, i.e., the second part of a CAIP chain ID.
+ */ export const CaipReferenceStruct = pattern(string(), CAIP_REFERENCE_REGEX);
+/**
+ * A CAIP-10 account ID, i.e., a human-readable namespace, reference, and account address.
+ */ export const CaipAccountIdStruct = pattern(string(), CAIP_ACCOUNT_ID_REGEX);
+/**
+ * A CAIP-10 account address, i.e., the third part of the CAIP account ID.
+ */ export const CaipAccountAddressStruct = pattern(string(), CAIP_ACCOUNT_ADDRESS_REGEX);
+/**
+ * Check if the given value is a {@link CaipChainId}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipChainId}.
+ */ export function isCaipChainId(value) {
+    return is(value, CaipChainIdStruct);
+}
+/**
+ * Check if the given value is a {@link CaipNamespace}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipNamespace}.
+ */ export function isCaipNamespace(value) {
+    return is(value, CaipNamespaceStruct);
+}
+/**
+ * Check if the given value is a {@link CaipReference}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipReference}.
+ */ export function isCaipReference(value) {
+    return is(value, CaipReferenceStruct);
+}
+/**
+ * Check if the given value is a {@link CaipAccountId}.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a {@link CaipAccountId}.
+ */ export function isCaipAccountId(value) {
+    return is(value, CaipAccountIdStruct);
+}
+/**
+ * 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 function isCaipAccountAddress(value) {
+    return is(value, CaipAccountAddressStruct);
+}
+/**
+ * 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 function parseCaipChainId(caipChainId) {
+    const match = CAIP_CHAIN_ID_REGEX.exec(caipChainId);
+    if (!match?.groups) {
+        throw new Error('Invalid CAIP chain ID.');
+    }
+    return {
+        namespace: match.groups.namespace,
+        reference: match.groups.reference
+    };
+}
+/**
+ * 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 function parseCaipAccountId(caipAccountId) {
+    const match = CAIP_ACCOUNT_ID_REGEX.exec(caipAccountId);
+    if (!match?.groups) {
+        throw new Error('Invalid CAIP account ID.');
+    }
+    return {
+        address: match.groups.accountAddress,
+        chainId: match.groups.chainId,
+        chain: {
+            namespace: match.groups.namespace,
+            reference: match.groups.reference
+        }
+    };
+}
+
+//# sourceMappingURL=caip-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/caip-types.ts"],"sourcesContent":["import type { Infer } from 'superstruct';\nimport { is, pattern, string } from 'superstruct';\n\nexport const CAIP_CHAIN_ID_REGEX =\n  /^(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})$/u;\n\nexport const CAIP_NAMESPACE_REGEX = /^[-a-z0-9]{3,8}$/u;\n\nexport const CAIP_REFERENCE_REGEX = /^[-_a-zA-Z0-9]{1,32}$/u;\n\nexport const CAIP_ACCOUNT_ID_REGEX =\n  /^(?<chainId>(?<namespace>[-a-z0-9]{3,8}):(?<reference>[-_a-zA-Z0-9]{1,32})):(?<accountAddress>[-.%a-zA-Z0-9]{1,128})$/u;\n\nexport const CAIP_ACCOUNT_ADDRESS_REGEX = /^[-.%a-zA-Z0-9]{1,128}$/u;\n\n/**\n * A CAIP-2 chain ID, i.e., a human-readable namespace and reference.\n */\nexport const CaipChainIdStruct = pattern(string(), CAIP_CHAIN_ID_REGEX);\nexport type CaipChainId = `${string}:${string}`;\n\n/**\n * A CAIP-2 namespace, i.e., the first part of a CAIP chain ID.\n */\nexport const CaipNamespaceStruct = pattern(string(), CAIP_NAMESPACE_REGEX);\nexport type CaipNamespace = Infer<typeof CaipNamespaceStruct>;\n\n/**\n * A CAIP-2 reference, i.e., the second part of a CAIP chain ID.\n */\nexport const CaipReferenceStruct = pattern(string(), CAIP_REFERENCE_REGEX);\nexport type CaipReference = Infer<typeof CaipReferenceStruct>;\n\n/**\n * A CAIP-10 account ID, i.e., a human-readable namespace, reference, and account address.\n */\nexport const CaipAccountIdStruct = pattern(string(), CAIP_ACCOUNT_ID_REGEX);\nexport type CaipAccountId = `${string}:${string}:${string}`;\n\n/**\n * A CAIP-10 account address, i.e., the third part of the CAIP account ID.\n */\nexport const CaipAccountAddressStruct = pattern(\n  string(),\n  CAIP_ACCOUNT_ADDRESS_REGEX,\n);\nexport type CaipAccountAddress = Infer<typeof CaipAccountAddressStruct>;\n\n/**\n * Check if the given value is a {@link CaipChainId}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipChainId}.\n */\nexport function isCaipChainId(value: unknown): value is CaipChainId {\n  return is(value, CaipChainIdStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipNamespace}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipNamespace}.\n */\nexport function isCaipNamespace(value: unknown): value is CaipNamespace {\n  return is(value, CaipNamespaceStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipReference}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipReference}.\n */\nexport function isCaipReference(value: unknown): value is CaipReference {\n  return is(value, CaipReferenceStruct);\n}\n\n/**\n * Check if the given value is a {@link CaipAccountId}.\n *\n * @param value - The value to check.\n * @returns Whether the value is a {@link CaipAccountId}.\n */\nexport function isCaipAccountId(value: unknown): value is CaipAccountId {\n  return is(value, CaipAccountIdStruct);\n}\n\n/**\n * Check if a value is a {@link CaipAccountAddress}.\n *\n * @param value - The value to validate.\n * @returns True if the value is a valid {@link CaipAccountAddress}.\n */\nexport function isCaipAccountAddress(\n  value: unknown,\n): value is CaipAccountAddress {\n  return is(value, CaipAccountAddressStruct);\n}\n\n/**\n * Parse a CAIP-2 chain ID to an object containing the namespace and reference.\n * This validates the CAIP-2 chain ID before parsing it.\n *\n * @param caipChainId - The CAIP-2 chain ID to validate and parse.\n * @returns The parsed CAIP-2 chain ID.\n */\nexport function parseCaipChainId(caipChainId: CaipChainId): {\n  namespace: CaipNamespace;\n  reference: CaipReference;\n} {\n  const match = CAIP_CHAIN_ID_REGEX.exec(caipChainId);\n  if (!match?.groups) {\n    throw new Error('Invalid CAIP chain ID.');\n  }\n\n  return {\n    namespace: match.groups.namespace as CaipNamespace,\n    reference: match.groups.reference as CaipReference,\n  };\n}\n\n/**\n * Parse an CAIP-10 account ID to an object containing the chain ID, parsed chain ID, and account address.\n * This validates the CAIP-10 account ID before parsing it.\n *\n * @param caipAccountId - The CAIP-10 account ID to validate and parse.\n * @returns The parsed CAIP-10 account ID.\n */\nexport function parseCaipAccountId(caipAccountId: CaipAccountId): {\n  address: CaipAccountAddress;\n  chainId: CaipChainId;\n  chain: { namespace: CaipNamespace; reference: CaipReference };\n} {\n  const match = CAIP_ACCOUNT_ID_REGEX.exec(caipAccountId);\n  if (!match?.groups) {\n    throw new Error('Invalid CAIP account ID.');\n  }\n\n  return {\n    address: match.groups.accountAddress as CaipAccountAddress,\n    chainId: match.groups.chainId as CaipChainId,\n    chain: {\n      namespace: match.groups.namespace as CaipNamespace,\n      reference: match.groups.reference as CaipReference,\n    },\n  };\n}\n"],"names":["is","pattern","string","CAIP_CHAIN_ID_REGEX","CAIP_NAMESPACE_REGEX","CAIP_REFERENCE_REGEX","CAIP_ACCOUNT_ID_REGEX","CAIP_ACCOUNT_ADDRESS_REGEX","CaipChainIdStruct","CaipNamespaceStruct","CaipReferenceStruct","CaipAccountIdStruct","CaipAccountAddressStruct","isCaipChainId","value","isCaipNamespace","isCaipReference","isCaipAccountId","isCaipAccountAddress","parseCaipChainId","caipChainId","match","exec","groups","Error","namespace","reference","parseCaipAccountId","caipAccountId","address","accountAddress","chainId","chain"],"mappings":"AACA,SAASA,EAAE,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAElD,OAAO,MAAMC,sBACX,gFAAoE;AAEtE,OAAO,MAAMC,uBAAuB,oBAAoB;AAExD,OAAO,MAAMC,uBAAuB,yBAAyB;AAE7D,OAAO,MAAMC,wBACX,qIAAyH;AAE3H,OAAO,MAAMC,6BAA6B,2BAA2B;AAErE;;CAEC,GACD,OAAO,MAAMC,oBAAoBP,QAAQC,UAAUC,qBAAqB;AAGxE;;CAEC,GACD,OAAO,MAAMM,sBAAsBR,QAAQC,UAAUE,sBAAsB;AAG3E;;CAEC,GACD,OAAO,MAAMM,sBAAsBT,QAAQC,UAAUG,sBAAsB;AAG3E;;CAEC,GACD,OAAO,MAAMM,sBAAsBV,QAAQC,UAAUI,uBAAuB;AAG5E;;CAEC,GACD,OAAO,MAAMM,2BAA2BX,QACtCC,UACAK,4BACA;AAGF;;;;;CAKC,GACD,OAAO,SAASM,cAAcC,KAAc;IAC1C,OAAOd,GAAGc,OAAON;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASO,gBAAgBD,KAAc;IAC5C,OAAOd,GAAGc,OAAOL;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASO,gBAAgBF,KAAc;IAC5C,OAAOd,GAAGc,OAAOJ;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASO,gBAAgBH,KAAc;IAC5C,OAAOd,GAAGc,OAAOH;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASO,qBACdJ,KAAc;IAEd,OAAOd,GAAGc,OAAOF;AACnB;AAEA;;;;;;CAMC,GACD,OAAO,SAASO,iBAAiBC,WAAwB;IAIvD,MAAMC,QAAQlB,oBAAoBmB,IAAI,CAACF;IACvC,IAAI,CAACC,OAAOE,QAAQ;QAClB,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAO;QACLC,WAAWJ,MAAME,MAAM,CAACE,SAAS;QACjCC,WAAWL,MAAME,MAAM,CAACG,SAAS;IACnC;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,mBAAmBC,aAA4B;IAK7D,MAAMP,QAAQf,sBAAsBgB,IAAI,CAACM;IACzC,IAAI,CAACP,OAAOE,QAAQ;QAClB,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAO;QACLK,SAASR,MAAME,MAAM,CAACO,cAAc;QACpCC,SAASV,MAAME,MAAM,CAACQ,OAAO;QAC7BC,OAAO;YACLP,WAAWJ,MAAME,MAAM,CAACE,SAAS;YACjCC,WAAWL,MAAME,MAAM,CAACG,SAAS;QACnC;IACF;AACF"}

package/dist/esm/checksum.js

@@ -0,0 +1,7 @@
+import { size, string } from 'superstruct';
+import { base64 } from './base64';
+export const ChecksumStruct = size(base64(string(), {
+    paddingRequired: true
+}), 44, 44);
+
+//# sourceMappingURL=checksum.js.map

package/dist/esm/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/checksum.ts"],"sourcesContent":["import { size, string } from 'superstruct';\n\nimport { base64 } from './base64';\n\nexport const ChecksumStruct = size(\n  base64(string(), { paddingRequired: true }),\n  44,\n  44,\n);\n"],"names":["size","string","base64","ChecksumStruct","paddingRequired"],"mappings":"AAAA,SAASA,IAAI,EAAEC,MAAM,QAAQ,cAAc;AAE3C,SAASC,MAAM,QAAQ,WAAW;AAElC,OAAO,MAAMC,iBAAiBH,KAC5BE,OAAOD,UAAU;IAAEG,iBAAiB;AAAK,IACzC,IACA,IACA"}

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

@@ -1,16 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHex = exports.createBytes = exports.createBigInt = exports.createNumber = void 0;
-const superstruct_1 = require("superstruct");
-const assert_1 = require("./assert");
-const bytes_1 = require("./bytes");
-const hex_1 = require("./hex");
-const NumberLikeStruct = (0, superstruct_1.union)([(0, superstruct_1.number)(), (0, superstruct_1.bigint)(), (0, superstruct_1.string)(), hex_1.StrictHexStruct]);
-const NumberCoercer = (0, superstruct_1.coerce)((0, superstruct_1.number)(), NumberLikeStruct, Number);
-const BigIntCoercer = (0, superstruct_1.coerce)((0, superstruct_1.bigint)(), NumberLikeStruct, BigInt);
-const BytesLikeStruct = (0, superstruct_1.union)([hex_1.StrictHexStruct, (0, superstruct_1.instance)(Uint8Array)]);
-const BytesCoercer = (0, superstruct_1.coerce)((0, superstruct_1.instance)(Uint8Array), (0, superstruct_1.union)([hex_1.StrictHexStruct]), bytes_1.hexToBytes);
-const HexCoercer = (0, superstruct_1.coerce)(hex_1.StrictHexStruct, (0, superstruct_1.instance)(Uint8Array), bytes_1.bytesToHex);
+import { bigint, coerce, create, instance, number, string, StructError, union } from 'superstruct';
+import { assert } from './assert';
+import { bytesToHex, hexToBytes } from './bytes';
+import { StrictHexStruct } from './hex';
+const NumberLikeStruct = union([
+    number(),
+    bigint(),
+    string(),
+    StrictHexStruct
+]);
+const NumberCoercer = coerce(number(), NumberLikeStruct, Number);
+const BigIntCoercer = coerce(bigint(), NumberLikeStruct, BigInt);
+const BytesLikeStruct = union([
+    StrictHexStruct,
+    instance(Uint8Array)
+]);
+const BytesCoercer = coerce(instance(Uint8Array), union([
+    StrictHexStruct
+]), hexToBytes);
+const HexCoercer = coerce(StrictHexStruct, instance(Uint8Array), bytesToHex);
 /**
  * Create a number from a number-like value.
  *
@@ -35,22 +42,18 @@ const HexCoercer = (0, superstruct_1.coerce)(hex_1.StrictHexStruct, (0, superstr
  * @returns The created number.
  * @throws If the value is not a number-like value, or if the resulting number
  * is `NaN` or `Infinity`.
- */
-function createNumber(value) {
+ */ export function createNumber(value) {
     try {
-        const result = (0, superstruct_1.create)(value, NumberCoercer);
-        (0, assert_1.assert)(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
+        const result = create(value, NumberCoercer);
+        assert(Number.isFinite(result), `Expected a number-like value, got "${value}".`);
         return result;
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a number-like value, got "${value}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createNumber = createNumber;
 /**
  * Create a `bigint` from a number-like value.
  *
@@ -72,22 +75,18 @@ exports.createNumber = createNumber;
  * @param value - The value to create the bigint from.
  * @returns The created bigint.
  * @throws If the value is not a number-like value.
- */
-function createBigInt(value) {
+ */ export 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_1.create)(value, BigIntCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, BigIntCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a number-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createBigInt = createBigInt;
 /**
  * Create a byte array from a bytes-like value.
  *
@@ -106,23 +105,19 @@ exports.createBigInt = createBigInt;
  * @param value - The value to create the byte array from.
  * @returns The created byte array.
  * @throws If the value is not a bytes-like value.
- */
-function createBytes(value) {
+ */ export function createBytes(value) {
     if (typeof value === 'string' && value.toLowerCase() === '0x') {
         return new Uint8Array();
     }
     try {
-        return (0, superstruct_1.create)(value, BytesCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, BytesCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createBytes = createBytes;
 /**
  * Create a hexadecimal string from a bytes-like value.
  *
@@ -141,22 +136,18 @@ exports.createBytes = createBytes;
  * @param value - The value to create the hex string from.
  * @returns The created hex string.
  * @throws If the value is not a bytes-like value.
- */
-function createHex(value) {
-    if ((value instanceof Uint8Array && value.length === 0) ||
-        (typeof value === 'string' && value.toLowerCase() === '0x')) {
+ */ export function createHex(value) {
+    if (value instanceof Uint8Array && value.length === 0 || typeof value === 'string' && value.toLowerCase() === '0x') {
         return '0x';
     }
     try {
-        return (0, superstruct_1.create)(value, HexCoercer);
-    }
-    catch (error) {
-        if (error instanceof superstruct_1.StructError) {
+        return create(value, HexCoercer);
+    } catch (error) {
+        if (error instanceof StructError) {
             throw new Error(`Expected a bytes-like value, got "${String(error.value)}".`);
         }
-        /* istanbul ignore next */
-        throw error;
+        /* istanbul ignore next */ throw error;
     }
 }
-exports.createHex = createHex;
+
 //# sourceMappingURL=coercers.js.map

package/dist/esm/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":["bigint","coerce","create","instance","number","string","StructError","union","assert","bytesToHex","hexToBytes","StrictHexStruct","NumberLikeStruct","NumberCoercer","Number","BigIntCoercer","BigInt","BytesLikeStruct","Uint8Array","BytesCoercer","HexCoercer","createNumber","value","result","isFinite","error","Error","createBigInt","String","createBytes","toLowerCase","createHex","length"],"mappings":"AACA,SACEA,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,QAAQ,EACRC,MAAM,EACNC,MAAM,EACNC,WAAW,EACXC,KAAK,QACA,cAAc;AAErB,SAASC,MAAM,QAAQ,WAAW;AAClC,SAASC,UAAU,EAAEC,UAAU,QAAQ,UAAU;AAEjD,SAASC,eAAe,QAAQ,QAAQ;AAExC,MAAMC,mBAAmBL,MAAM;IAACH;IAAUJ;IAAUK;IAAUM;CAAgB;AAC9E,MAAME,gBAAgBZ,OAAOG,UAAUQ,kBAAkBE;AACzD,MAAMC,gBAAgBd,OAAOD,UAAUY,kBAAkBI;AAEzD,MAAMC,kBAAkBV,MAAM;IAACI;IAAiBR,SAASe;CAAY;AACrE,MAAMC,eAAelB,OACnBE,SAASe,aACTX,MAAM;IAACI;CAAgB,GACvBD;AAGF,MAAMU,aAAanB,OAAOU,iBAAiBR,SAASe,aAAaT;AAKjE;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASY,aAAaC,KAAiB;IAC5C,IAAI;QACF,MAAMC,SAASrB,OAAOoB,OAAOT;QAE7BL,OACEM,OAAOU,QAAQ,CAACD,SAChB,CAAC,mCAAmC,EAAED,MAAM,EAAE,CAAC;QAGjD,OAAOC;IACT,EAAE,OAAOE,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MAAM,CAAC,mCAAmC,EAAEJ,MAAM,EAAE,CAAC;QACjE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASE,aAAaL,KAAiB;IAC5C,IAAI;QACF,2EAA2E;QAC3E,mDAAmD;QACnD,OAAOpB,OAAOoB,OAAOP;IACvB,EAAE,OAAOU,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,mCAAmC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEjE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASI,YAAYP,KAAgB;IAC1C,IAAI,OAAOA,UAAU,YAAYA,MAAMQ,WAAW,OAAO,MAAM;QAC7D,OAAO,IAAIZ;IACb;IAEA,IAAI;QACF,OAAOhB,OAAOoB,OAAOH;IACvB,EAAE,OAAOM,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,kCAAkC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASM,UAAUT,KAAgB;IACxC,IACE,AAACA,iBAAiBJ,cAAcI,MAAMU,MAAM,KAAK,KAChD,OAAOV,UAAU,YAAYA,MAAMQ,WAAW,OAAO,MACtD;QACA,OAAO;IACT;IAEA,IAAI;QACF,OAAO5B,OAAOoB,OAAOF;IACvB,EAAE,OAAOK,OAAO;QACd,IAAIA,iBAAiBnB,aAAa;YAChC,MAAM,IAAIoB,MACR,CAAC,kCAAkC,EAAEE,OAAOH,MAAMH,KAAK,EAAE,EAAE,CAAC;QAEhE;QAEA,wBAAwB,GACxB,MAAMG;IACR;AACF"}

package/dist/esm/collections.js

@@ -0,0 +1,140 @@
+/**
+ * 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.
+ */ 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);
+export { FrozenMap, FrozenSet };
+
+//# sourceMappingURL=collections.js.map

package/dist/esm/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":["Symbol","iterator","FrozenMap","size","map","entries","forEach","callbackfn","thisArg","value","key","_map","call","get","has","keys","values","toString","String","join","constructor","Map","Object","freeze","FrozenSet","set","value2","_set","member","Set","prototype"],"mappings":"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"}

package/dist/esm/encryption-types.js

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/encryption-types.ts"],"sourcesContent":["export type Eip1024EncryptedData = {\n  version: string;\n  nonce: string;\n  ephemPublicKey: string;\n  ciphertext: string;\n};\n"],"names":[],"mappings":"AAAA,WAKE"}

package/dist/esm/hex.js

@@ -0,0 +1,108 @@
+import { keccak_256 as keccak256 } from '@noble/hashes/sha3';
+import { is, pattern, string } from 'superstruct';
+import { assert } from './assert';
+import { bytesToHex } from './bytes';
+export const HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);
+export const StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu);
+export const HexAddressStruct = pattern(string(), /^0x[0-9a-f]{40}$/u);
+export const HexChecksumAddressStruct = pattern(string(), /^0x[0-9a-fA-F]{40}$/u);
+/**
+ * Check if a string is a valid hex string.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid hex string.
+ */ export function isHexString(value) {
+    return is(value, HexStruct);
+}
+/**
+ * Strictly check if a string is a valid hex string. A valid hex string must
+ * start with the "0x"-prefix.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a valid hex string.
+ */ export function isStrictHexString(value) {
+    return is(value, StrictHexStruct);
+}
+/**
+ * Assert that a value is a valid hex string.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a valid hex string.
+ */ export function assertIsHexString(value) {
+    assert(isHexString(value), 'Value must be a hexadecimal string.');
+}
+/**
+ * Assert that a value is a valid hex string. A valid hex string must start with
+ * the "0x"-prefix.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a valid hex string.
+ */ export function assertIsStrictHexString(value) {
+    assert(isStrictHexString(value), 'Value must be a hexadecimal string, starting with "0x".');
+}
+/**
+ * Validate that the passed prefixed hex string is an all-lowercase
+ * hex address, or a valid mixed-case checksum address.
+ *
+ * @param possibleAddress - Input parameter to check against.
+ * @returns Whether or not the input is a valid hex address.
+ */ export function isValidHexAddress(possibleAddress) {
+    return is(possibleAddress, HexAddressStruct) || isValidChecksumAddress(possibleAddress);
+}
+/**
+ * Encode a passed hex string as an ERC-55 mixed-case checksum address.
+ *
+ * @param address - The hex address to encode.
+ * @returns The address encoded according to ERC-55.
+ * @see https://eips.ethereum.org/EIPS/eip-55
+ */ export function getChecksumAddress(address) {
+    assert(is(address, HexChecksumAddressStruct), 'Invalid hex address.');
+    const unPrefixed = remove0x(address.toLowerCase());
+    const unPrefixedHash = remove0x(bytesToHex(keccak256(unPrefixed)));
+    return `0x${unPrefixed.split('').map((character, nibbleIndex)=>{
+        const hashCharacter = unPrefixedHash[nibbleIndex];
+        assert(is(hashCharacter, string()), 'Hash shorter than address.');
+        return parseInt(hashCharacter, 16) > 7 ? character.toUpperCase() : character;
+    }).join('')}`;
+}
+/**
+ * Validate that the passed hex string is a valid ERC-55 mixed-case
+ * checksum address.
+ *
+ * @param possibleChecksum - The hex address to check.
+ * @returns True if the address is a checksum address.
+ */ export function isValidChecksumAddress(possibleChecksum) {
+    if (!is(possibleChecksum, HexChecksumAddressStruct)) {
+        return false;
+    }
+    return getChecksumAddress(possibleChecksum) === possibleChecksum;
+}
+/**
+ * Add the `0x`-prefix to a hexadecimal string. If the string already has the
+ * prefix, it is returned as-is.
+ *
+ * @param hexadecimal - The hexadecimal string to add the prefix to.
+ * @returns The prefixed hexadecimal string.
+ */ export function add0x(hexadecimal) {
+    if (hexadecimal.startsWith('0x')) {
+        return hexadecimal;
+    }
+    if (hexadecimal.startsWith('0X')) {
+        return `0x${hexadecimal.substring(2)}`;
+    }
+    return `0x${hexadecimal}`;
+}
+/**
+ * Remove the `0x`-prefix from a hexadecimal string. If the string doesn't have
+ * the prefix, it is returned as-is.
+ *
+ * @param hexadecimal - The hexadecimal string to remove the prefix from.
+ * @returns The un-prefixed hexadecimal string.
+ */ export function remove0x(hexadecimal) {
+    if (hexadecimal.startsWith('0x') || hexadecimal.startsWith('0X')) {
+        return hexadecimal.substring(2);
+    }
+    return hexadecimal;
+}
+
+//# sourceMappingURL=hex.js.map

package/dist/esm/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":["keccak_256","keccak256","is","pattern","string","assert","bytesToHex","HexStruct","StrictHexStruct","HexAddressStruct","HexChecksumAddressStruct","isHexString","value","isStrictHexString","assertIsHexString","assertIsStrictHexString","isValidHexAddress","possibleAddress","isValidChecksumAddress","getChecksumAddress","address","unPrefixed","remove0x","toLowerCase","unPrefixedHash","split","map","character","nibbleIndex","hashCharacter","parseInt","toUpperCase","join","possibleChecksum","add0x","hexadecimal","startsWith","substring"],"mappings":"AAAA,SAASA,cAAcC,SAAS,QAAQ,qBAAqB;AAE7D,SAASC,EAAE,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAElD,SAASC,MAAM,QAAQ,WAAW;AAClC,SAASC,UAAU,QAAQ,UAAU;AAIrC,OAAO,MAAMC,YAAYJ,QAAQC,UAAU,wBAAwB;AACnE,OAAO,MAAMI,kBAAkBL,QAAQC,UAAU,mBAG/C;AACF,OAAO,MAAMK,mBAAmBN,QAC9BC,UACA,qBACqB;AACvB,OAAO,MAAMM,2BAA2BP,QACtCC,UACA,wBACqB;AAEvB;;;;;CAKC,GACD,OAAO,SAASO,YAAYC,KAAc;IACxC,OAAOV,GAAGU,OAAOL;AACnB;AAEA;;;;;;CAMC,GACD,OAAO,SAASM,kBAAkBD,KAAc;IAC9C,OAAOV,GAAGU,OAAOJ;AACnB;AAEA;;;;;CAKC,GACD,OAAO,SAASM,kBAAkBF,KAAc;IAC9CP,OAAOM,YAAYC,QAAQ;AAC7B;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,wBAAwBH,KAAc;IACpDP,OACEQ,kBAAkBD,QAClB;AAEJ;AAEA;;;;;;CAMC,GACD,OAAO,SAASI,kBAAkBC,eAAoB;IACpD,OACEf,GAAGe,iBAAiBR,qBACpBS,uBAAuBD;AAE3B;AAEA;;;;;;CAMC,GACD,OAAO,SAASE,mBAAmBC,OAAY;IAC7Cf,OAAOH,GAAGkB,SAASV,2BAA2B;IAC9C,MAAMW,aAAaC,SAASF,QAAQG,WAAW;IAC/C,MAAMC,iBAAiBF,SAAShB,WAAWL,UAAUoB;IACrD,OAAO,CAAC,EAAE,EAAEA,WACTI,KAAK,CAAC,IACNC,GAAG,CAAC,CAACC,WAAWC;QACf,MAAMC,gBAAgBL,cAAc,CAACI,YAAY;QACjDvB,OAAOH,GAAG2B,eAAezB,WAAW;QACpC,OAAO0B,SAASD,eAAe,MAAM,IACjCF,UAAUI,WAAW,KACrBJ;IACN,GACCK,IAAI,CAAC,IAAI,CAAC;AACf;AAEA;;;;;;CAMC,GACD,OAAO,SAASd,uBAAuBe,gBAAqB;IAC1D,IAAI,CAAC/B,GAAG+B,kBAAkBvB,2BAA2B;QACnD,OAAO;IACT;IAEA,OAAOS,mBAAmBc,sBAAsBA;AAClD;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,MAAMC,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;AAEA;;;;;;CAMC,GACD,OAAO,SAASb,SAASa,WAAmB;IAC1C,IAAIA,YAAYC,UAAU,CAAC,SAASD,YAAYC,UAAU,CAAC,OAAO;QAChE,OAAOD,YAAYE,SAAS,CAAC;IAC/B;IAEA,OAAOF;AACT"}