@metamask/utils 8.4.0 → 9.0.0

package/dist/fs.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"fs.mjs","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"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","sourcesContent":["// This file is intended to be used only in a Node.js context.\n/* eslint-disable import/no-nodejs-modules */\n\nimport fs from 'fs';\nimport os from 'os';\nimport path from 'path';\nimport * as uuid from 'uuid';\n\nimport { isErrorWithCode, wrapError } from './errors';\nimport type { Json } from './json';\n\n/**\n * Information about the file sandbox provided to tests that need temporary\n * access to the filesystem.\n */\nexport type FileSandbox = {\n  directoryPath: string;\n  withinSandbox: (\n    test: (args: { directoryPath: string }) => Promise<void>,\n  ) => Promise<void>;\n};\n\n/**\n * Read the file at the given path, assuming its content is encoded as UTF-8.\n *\n * @param filePath - The path to the file.\n * @returns The content of the file.\n * @throws An error with a stack trace if reading fails in any way.\n */\nexport async function readFile(filePath: string): Promise<string> {\n  try {\n    return await fs.promises.readFile(filePath, 'utf8');\n  } catch (error) {\n    throw wrapError(error, `Could not read file '${filePath}'`);\n  }\n}\n\n/**\n * Write content to the file at the given path, creating the directory structure\n * for the file automatically if necessary.\n *\n * @param filePath - The path to the file.\n * @param content - The new content of the file.\n * @throws An error with a stack trace if writing fails in any way.\n */\nexport async function writeFile(\n  filePath: string,\n  content: string,\n): Promise<void> {\n  try {\n    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n    await fs.promises.writeFile(filePath, content);\n  } catch (error) {\n    throw wrapError(error, `Could not write file '${filePath}'`);\n  }\n}\n\n/**\n * Read the assumed JSON file at the given path, attempts to parse it, and\n * get the resulting object. Supports a custom parser (in case you want to\n * use the [JSON5](https://www.npmjs.com/package/json5) package instead).\n *\n * @param filePath - The path segments pointing to the JSON file. Will be passed\n * to path.join().\n * @param options - Options to this function.\n * @param options.parser - The parser object to use. Defaults to `JSON`.\n * @param options.parser.parse - A function that parses JSON data.\n * @returns The object corresponding to the parsed JSON file, typed against the\n * struct.\n * @throws An error with a stack trace if reading fails in any way, or if the\n * parsed value is not a plain object.\n */\nexport async function readJsonFile<Value extends Json>(\n  filePath: string,\n  {\n    parser = JSON,\n  }: {\n    parser?: {\n      parse: (\n        text: Parameters<typeof JSON.parse>[0],\n      ) => ReturnType<typeof JSON.parse>;\n    };\n  } = {},\n): Promise<Value> {\n  try {\n    const content = await fs.promises.readFile(filePath, 'utf8');\n    return parser.parse(content);\n  } catch (error) {\n    throw wrapError(error, `Could not read JSON file '${filePath}'`);\n  }\n}\n\n/**\n * Attempt to write the given JSON-like value to the file at the given path,\n * creating the directory structure for the file automatically if necessary.\n * Adds a newline to the end of the file. Supports a custom parser (in case you\n * want to use the [JSON5](https://www.npmjs.com/package/json5) package\n * instead).\n *\n * @param filePath - The path to write the JSON file to, including the file\n * itself.\n * @param jsonValue - The JSON-like value to write to the file. Make sure that\n * JSON.stringify can handle it.\n * @param options - The options to this function.\n * @param options.prettify - Whether to format the JSON as it is turned into a\n * string such that it is broken up into separate lines (using 2 spaces as\n * indentation).\n * @param options.stringifier - The stringifier to use. Defaults to `JSON`.\n * @param options.stringifier.stringify - A function that stringifies JSON.\n * @returns The object corresponding to the parsed JSON file, typed against the\n * struct.\n * @throws An error with a stack trace if writing fails in any way.\n */\nexport async function writeJsonFile(\n  filePath: string,\n  jsonValue: Json,\n  {\n    stringifier = JSON,\n    prettify = false,\n  }: {\n    stringifier?: {\n      stringify: typeof JSON.stringify;\n    };\n    prettify?: boolean;\n  } = {},\n): Promise<void> {\n  try {\n    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n    const json = prettify\n      ? stringifier.stringify(jsonValue, null, '  ')\n      : stringifier.stringify(jsonValue);\n    await fs.promises.writeFile(filePath, json);\n  } catch (error) {\n    throw wrapError(error, `Could not write JSON file '${filePath}'`);\n  }\n}\n\n/**\n * Test the given path to determine whether it represents a file.\n *\n * @param filePath - The path to a (supposed) file on the filesystem.\n * @returns A promise for true if the file exists or false otherwise.\n * @throws An error with a stack trace if reading fails in any way.\n */\nexport async function fileExists(filePath: string): Promise<boolean> {\n  try {\n    const stats = await fs.promises.stat(filePath);\n    return stats.isFile();\n  } catch (error) {\n    if (isErrorWithCode(error) && error.code === 'ENOENT') {\n      return false;\n    }\n\n    throw wrapError(error, `Could not determine if file exists '${filePath}'`);\n  }\n}\n\n/**\n * Test the given path to determine whether it represents a directory.\n *\n * @param directoryPath - The path to a (supposed) directory on the filesystem.\n * @returns A promise for true if the file exists or false otherwise.\n * @throws An error with a stack trace if reading fails in any way.\n */\nexport async function directoryExists(directoryPath: string): Promise<boolean> {\n  try {\n    const stats = await fs.promises.stat(directoryPath);\n    return stats.isDirectory();\n  } catch (error) {\n    if (isErrorWithCode(error) && error.code === 'ENOENT') {\n      return false;\n    }\n\n    throw wrapError(\n      error,\n      `Could not determine if directory exists '${directoryPath}'`,\n    );\n  }\n}\n\n/**\n * Create the given directory along with any directories leading up to the\n * directory, or do nothing if the directory already exists.\n *\n * @param directoryPath - The path to the desired directory.\n * @throws An error with a stack trace if reading fails in any way.\n */\nexport async function ensureDirectoryStructureExists(\n  directoryPath: string,\n): Promise<void> {\n  try {\n    await fs.promises.mkdir(directoryPath, { recursive: true });\n  } catch (error) {\n    throw wrapError(\n      error,\n      `Could not create directory structure '${directoryPath}'`,\n    );\n  }\n}\n\n/**\n * Remove the given file or directory if it exists, or do nothing if it does\n * not.\n *\n * @param entryPath - The path to the file or directory.\n * @throws An error with a stack trace if removal fails in any way.\n */\nexport async function forceRemove(entryPath: string): Promise<void> {\n  try {\n    return await fs.promises.rm(entryPath, {\n      recursive: true,\n      force: true,\n    });\n  } catch (error) {\n    throw wrapError(error, `Could not remove file or directory '${entryPath}'`);\n  }\n}\n\n/**\n * Construct a sandbox object which can be used in tests that need temporary\n * access to the filesystem.\n *\n * @param projectName - The name of the project.\n * @returns The sandbox object. This contains a `withinSandbox` function which\n * can be used in tests (see example).\n * @example\n * ```typescript\n * const { withinSandbox } = createSandbox('utils');\n *\n * // ... later ...\n *\n * it('does something with the filesystem', async () => {\n *   await withinSandbox(async ({ directoryPath }) => {\n *     await fs.promises.writeFile(\n *       path.join(directoryPath, 'some-file'),\n *       'some content',\n *       'utf8'\n *     );\n *   })\n * });\n * ```\n */\nexport function createSandbox(projectName: string): FileSandbox {\n  const directoryPath = path.join(os.tmpdir(), projectName, uuid.v4());\n\n  return {\n    directoryPath,\n    async withinSandbox(\n      test: (args: { directoryPath: string }) => Promise<void>,\n    ) {\n      if (await directoryExists(directoryPath)) {\n        throw new Error(`${directoryPath} already exists. Cannot continue.`);\n      }\n\n      await ensureDirectoryStructureExists(directoryPath);\n\n      try {\n        await test({ directoryPath });\n      } finally {\n        await forceRemove(directoryPath);\n      }\n    },\n  };\n}\n"]}

package/dist/hex.cjs

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

package/dist/hex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.cjs","sourceRoot":"","sources":["../src/hex.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport { is, pattern, string } from '@metamask/superstruct';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\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): 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"]}

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

@@ -1,5 +1,5 @@
-import type { Struct } from 'superstruct';
-export declare type Hex = `0x${string}`;
+import type { Struct } from "@metamask/superstruct";
+export type Hex = `0x${string}`;
 export declare const HexStruct: Struct<string, null>;
 export declare const StrictHexStruct: Struct<`0x${string}`, null>;
 export declare const HexAddressStruct: Struct<`0x${string}`, null>;
@@ -49,7 +49,7 @@ export declare function isValidHexAddress(possibleAddress: Hex): boolean;
  * @returns The address encoded according to ERC-55.
  * @see https://eips.ethereum.org/EIPS/eip-55
  */
-export declare function getChecksumAddress(address: Hex): string;
+export declare function getChecksumAddress(address: Hex): Hex;
 /**
  * Validate that the passed hex string is a valid ERC-55 mixed-case
  * checksum address.
@@ -74,4 +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
+//# sourceMappingURL=hex.d.cts.map

package/dist/hex.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.cts","sourceRoot":"","sources":["../src/hex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAOpD,MAAM,MAAM,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,GAAG,GAAG,CAcpD;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/hex.d.mts

@@ -0,0 +1,77 @@
+import type { Struct } from "@metamask/superstruct";
+export type Hex = `0x${string}`;
+export declare const HexStruct: Struct<string, null>;
+export declare const StrictHexStruct: Struct<`0x${string}`, null>;
+export declare const HexAddressStruct: Struct<`0x${string}`, null>;
+export declare const HexChecksumAddressStruct: Struct<`0x${string}`, null>;
+/**
+ * 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 declare function isHexString(value: unknown): value is string;
+/**
+ * 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 declare function isStrictHexString(value: unknown): value is Hex;
+/**
+ * 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 declare function assertIsHexString(value: unknown): asserts value is 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 declare function assertIsStrictHexString(value: unknown): asserts value is Hex;
+/**
+ * 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 declare function isValidHexAddress(possibleAddress: Hex): boolean;
+/**
+ * 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 declare function getChecksumAddress(address: Hex): Hex;
+/**
+ * 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 declare function isValidChecksumAddress(possibleChecksum: Hex): boolean;
+/**
+ * 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 declare function add0x(hexadecimal: string): Hex;
+/**
+ * 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 declare function remove0x(hexadecimal: string): string;
+//# sourceMappingURL=hex.d.mts.map

package/dist/hex.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.mts","sourceRoot":"","sources":["../src/hex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAOpD,MAAM,MAAM,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,GAAG,GAAG,CAcpD;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/hex.mjs

@@ -1,35 +1,122 @@
-import {
-  HexAddressStruct,
-  HexChecksumAddressStruct,
-  HexStruct,
-  StrictHexStruct,
-  add0x,
-  assertIsHexString,
-  assertIsStrictHexString,
-  getChecksumAddress,
-  isHexString,
-  isStrictHexString,
-  isValidChecksumAddress,
-  isValidHexAddress,
-  remove0x
-} from "./chunk-VA2DRBDE.mjs";
-import "./chunk-74DGVJVE.mjs";
-import "./chunk-XYGUOY6N.mjs";
-import "./chunk-H4YFDLB7.mjs";
-import "./chunk-X66SUIEF.mjs";
-export {
-  HexAddressStruct,
-  HexChecksumAddressStruct,
-  HexStruct,
-  StrictHexStruct,
-  add0x,
-  assertIsHexString,
-  assertIsStrictHexString,
-  getChecksumAddress,
-  isHexString,
-  isStrictHexString,
-  isValidChecksumAddress,
-  isValidHexAddress,
-  remove0x
-};
+import { is, pattern, string } from "@metamask/superstruct";
+import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
+import { assert } from "./assert.mjs";
+import { bytesToHex } from "./bytes.mjs";
+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.mjs.map

package/dist/hex.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"hex.mjs","sourceRoot":"","sources":["../src/hex.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport { is, pattern, string } from '@metamask/superstruct';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\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): 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"]}

package/dist/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assert.cjs"), exports);
+__exportStar(require("./base64.cjs"), exports);
+__exportStar(require("./bytes.cjs"), exports);
+__exportStar(require("./caip-types.cjs"), exports);
+__exportStar(require("./checksum.cjs"), exports);
+__exportStar(require("./coercers.cjs"), exports);
+__exportStar(require("./collections.cjs"), exports);
+__exportStar(require("./encryption-types.cjs"), exports);
+__exportStar(require("./errors.cjs"), exports);
+__exportStar(require("./hex.cjs"), exports);
+__exportStar(require("./json.cjs"), exports);
+__exportStar(require("./keyring.cjs"), exports);
+__exportStar(require("./logging.cjs"), exports);
+__exportStar(require("./misc.cjs"), exports);
+__exportStar(require("./number.cjs"), exports);
+__exportStar(require("./opaque.cjs"), exports);
+__exportStar(require("./promise.cjs"), exports);
+__exportStar(require("./time.cjs"), exports);
+__exportStar(require("./transaction-types.cjs"), exports);
+__exportStar(require("./versions.cjs"), exports);
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAAyB;AACzB,+CAAyB;AACzB,8CAAwB;AACxB,mDAA6B;AAC7B,iDAA2B;AAC3B,iDAA2B;AAC3B,oDAA8B;AAC9B,yDAAmC;AACnC,+CAAyB;AACzB,4CAAsB;AACtB,6CAAuB;AACvB,gDAA0B;AAC1B,gDAA0B;AAC1B,6CAAuB;AACvB,+CAAyB;AACzB,+CAAyB;AACzB,gDAA0B;AAC1B,6CAAuB;AACvB,0DAAoC;AACpC,iDAA2B","sourcesContent":["export * from './assert';\nexport * from './base64';\nexport * from './bytes';\nexport * from './caip-types';\nexport * from './checksum';\nexport * from './coercers';\nexport * from './collections';\nexport * from './encryption-types';\nexport * from './errors';\nexport * from './hex';\nexport * from './json';\nexport * from './keyring';\nexport * from './logging';\nexport * from './misc';\nexport * from './number';\nexport * from './opaque';\nexport * from './promise';\nexport * from './time';\nexport * from './transaction-types';\nexport * from './versions';\n"]}

package/dist/index.d.cts

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

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,6BAAyB;AACzB,6BAAyB;AACzB,4BAAwB;AACxB,iCAA6B;AAC7B,+BAA2B;AAC3B,+BAA2B;AAC3B,kCAA8B;AAC9B,uCAAmC;AACnC,6BAAyB;AACzB,0BAAsB;AACtB,2BAAuB;AACvB,8BAA0B;AAC1B,8BAA0B;AAC1B,2BAAuB;AACvB,6BAAyB;AACzB,6BAAyB;AACzB,8BAA0B;AAC1B,2BAAuB;AACvB,wCAAoC;AACpC,+BAA2B"}

package/dist/index.d.mts

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

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,6BAAyB;AACzB,6BAAyB;AACzB,4BAAwB;AACxB,iCAA6B;AAC7B,+BAA2B;AAC3B,+BAA2B;AAC3B,kCAA8B;AAC9B,uCAAmC;AACnC,6BAAyB;AACzB,0BAAsB;AACtB,2BAAuB;AACvB,8BAA0B;AAC1B,8BAA0B;AAC1B,2BAAuB;AACvB,6BAAyB;AACzB,6BAAyB;AACzB,8BAA0B;AAC1B,2BAAuB;AACvB,wCAAoC;AACpC,+BAA2B"}