@metamask/utils 3.0.2 → 3.1.0

package/README.md

@@ -21,7 +21,7 @@ The full API documentation for the latest published version of this library is [
 - Install [Node.js](https://nodejs.org) version 12
   - If you are using [nvm](https://github.com/creationix/nvm#installation) (recommended) running `nvm use` will automatically choose the right node version for you.
 - Install [Yarn v1](https://yarnpkg.com/en/docs/install)
-- Run `yarn setup` to install dependencies and run any requried post-install scripts
+- Run `yarn setup` to install dependencies and run any required post-install scripts
   - **Warning:** Do not use the `yarn` / `yarn install` command directly. Use `yarn setup` instead. The normal install command will skip required post-install scripts, leaving your development environment in an invalid state.
 
 ### Testing and Linting

package/dist/assert.d.ts

@@ -0,0 +1,36 @@
+export declare class AssertionError extends Error {
+    readonly code = "ERR_ASSERTION";
+    constructor(options: {
+        message: string;
+    });
+}
+/**
+ * Same as Node.js assert.
+ * If the value is falsy, throws an error, does nothing otherwise.
+ *
+ * @throws {@link AssertionError}. If value is falsy.
+ * @param value - The test that should be truthy to pass.
+ * @param message - Message to be passed to {@link AssertionError} or an
+ * {@link Error} instance to throw.
+ */
+export declare function assert(value: any, message?: string | Error): asserts value;
+/**
+ * Use in the default case of a switch that you want to be fully exhaustive.
+ * Using this function forces the compiler to enforce exhaustivity during
+ * compile-time.
+ *
+ * @example
+ * ```
+ * const number = 1;
+ * switch (number) {
+ *   case 0:
+ *     ...
+ *   case 1:
+ *     ...
+ *   default:
+ *     assertExhaustive(snapPrefix);
+ * }
+ * ```
+ * @param _object - The object on which the switch is being operated.
+ */
+export declare function assertExhaustive(_object: never): never;

package/dist/assert.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExhaustive = exports.assert = exports.AssertionError = void 0;
+class AssertionError extends Error {
+    constructor(options) {
+        super(options.message);
+        this.code = 'ERR_ASSERTION';
+    }
+}
+exports.AssertionError = AssertionError;
+/**
+ * Same as Node.js assert.
+ * If the value is falsy, throws an error, does nothing otherwise.
+ *
+ * @throws {@link AssertionError}. If value is falsy.
+ * @param value - The test that should be truthy to pass.
+ * @param message - Message to be passed to {@link AssertionError} or an
+ * {@link Error} instance to throw.
+ */
+function assert(value, message) {
+    if (!value) {
+        if (message instanceof Error) {
+            throw message;
+        }
+        throw new AssertionError({ message: message !== null && message !== void 0 ? message : 'Assertion failed.' });
+    }
+}
+exports.assert = assert;
+/**
+ * Use in the default case of a switch that you want to be fully exhaustive.
+ * Using this function forces the compiler to enforce exhaustivity during
+ * compile-time.
+ *
+ * @example
+ * ```
+ * const number = 1;
+ * switch (number) {
+ *   case 0:
+ *     ...
+ *   case 1:
+ *     ...
+ *   default:
+ *     assertExhaustive(snapPrefix);
+ * }
+ * ```
+ * @param _object - The object on which the switch is being operated.
+ */
+function assertExhaustive(_object) {
+    throw new Error('Invalid branch reached. Should be detected during compilation.');
+}
+exports.assertExhaustive = assertExhaustive;
+//# sourceMappingURL=assert.js.map

package/dist/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":";;;AAAA,MAAa,cAAe,SAAQ,KAAK;IAGvC,YAAY,OAA4B;QACtC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAHhB,SAAI,GAAG,eAAe,CAAC;IAIhC,CAAC;CACF;AAND,wCAMC;AAED;;;;;;;;GAQG;AACH,SAAgB,MAAM,CAAC,KAAU,EAAE,OAAwB;IACzD,IAAI,CAAC,KAAK,EAAE;QACV,IAAI,OAAO,YAAY,KAAK,EAAE;YAC5B,MAAM,OAAO,CAAC;SACf;QACD,MAAM,IAAI,cAAc,CAAC,EAAE,OAAO,EAAE,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,mBAAmB,EAAE,CAAC,CAAC;KACvE;AACH,CAAC;AAPD,wBAOC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,gBAAgB,CAAC,OAAc;IAC7C,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;AACJ,CAAC;AAJD,4CAIC","sourcesContent":["export class AssertionError extends Error {\n  readonly code = 'ERR_ASSERTION';\n\n  constructor(options: { message: string }) {\n    super(options.message);\n  }\n}\n\n/**\n * Same as Node.js assert.\n * If the value is falsy, throws an error, does nothing otherwise.\n *\n * @throws {@link AssertionError}. If value is falsy.\n * @param value - The test that should be truthy to pass.\n * @param message - Message to be passed to {@link AssertionError} or an\n * {@link Error} instance to throw.\n */\nexport function assert(value: any, message?: string | Error): asserts value {\n  if (!value) {\n    if (message instanceof Error) {\n      throw message;\n    }\n    throw new AssertionError({ message: message ?? 'Assertion failed.' });\n  }\n}\n\n/**\n * Use in the default case of a switch that you want to be fully exhaustive.\n * Using this function forces the compiler to enforce exhaustivity during\n * compile-time.\n *\n * @example\n * ```\n * const number = 1;\n * switch (number) {\n *   case 0:\n *     ...\n *   case 1:\n *     ...\n *   default:\n *     assertExhaustive(snapPrefix);\n * }\n * ```\n * @param _object - The object on which the switch is being operated.\n */\nexport function assertExhaustive(_object: never): never {\n  throw new Error(\n    'Invalid branch reached. Should be detected during compilation.',\n  );\n}\n"]}

package/dist/bytes.d.ts

@@ -0,0 +1,138 @@
+export declare type Bytes = bigint | number | string | Uint8Array;
+/**
+ * Check if a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `Uint8Array`.
+ */
+export declare function isBytes(value: unknown): value is Uint8Array;
+/**
+ * Assert that a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a `Uint8Array`.
+ */
+export declare function assertIsBytes(value: unknown): asserts value is Uint8Array;
+/**
+ * Convert a `Uint8Array` to a hexadecimal string.
+ *
+ * @param bytes - The bytes to convert to a hexadecimal string.
+ * @returns The hexadecimal string.
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Convert a `Uint8Array` to a `bigint`.
+ *
+ * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.
+ * To convert a two's complement encoded `Uint8Array` to a `bigint`, use
+ * {@link bytesToSignedBigInt}.
+ *
+ * @param bytes - The bytes to convert to a `bigint`.
+ * @returns The `bigint`.
+ */
+export declare function bytesToBigInt(bytes: Uint8Array): bigint;
+/**
+ * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are
+ * encoded in two's complement.
+ *
+ * To convert a `Uint8Array` to an unsigned `bigint` instead, use
+ * {@link bytesToBigInt}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param bytes - The bytes to convert to a signed `bigint`.
+ * @returns The signed `bigint`.
+ */
+export declare function bytesToSignedBigInt(bytes: Uint8Array): bigint;
+/**
+ * Convert a `Uint8Array` to a `number`.
+ *
+ * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.
+ *
+ * @param bytes - The bytes to convert to a number.
+ * @returns The number.
+ * @throws If the resulting number is not a safe integer.
+ */
+export declare function bytesToNumber(bytes: Uint8Array): number;
+/**
+ * Convert a UTF-8 encoded `Uint8Array` to a `string`.
+ *
+ * @param bytes - The bytes to convert to a string.
+ * @returns The string.
+ */
+export declare function bytesToString(bytes: Uint8Array): string;
+/**
+ * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be
+ * prefixed with `0x`. It accepts even and odd length strings.
+ *
+ * @param value - The hexadecimal string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function hexToBytes(value: string): Uint8Array;
+/**
+ * Convert a `bigint` to a `Uint8Array`.
+ *
+ * This assumes that the `bigint` is an unsigned integer. To convert a signed
+ * `bigint` instead, use {@link signedBigIntToBytes}.
+ *
+ * @param value - The bigint to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function bigIntToBytes(value: bigint): Uint8Array;
+/**
+ * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement
+ * encoding to represent negative numbers.
+ *
+ * To convert an unsigned `bigint` to a `Uint8Array` instead, use
+ * {@link bigIntToBytes}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param value - The number to convert to bytes.
+ * @param byteLength - The length of the resulting `Uint8Array`. If the number
+ * is larger than the maximum value that can be represented by the given length,
+ * an error is thrown.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function signedBigIntToBytes(value: bigint, byteLength: number): Uint8Array;
+/**
+ * Convert a `number` to a `Uint8Array`.
+ *
+ * @param value - The number to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ * @throws If the number is not a safe integer.
+ */
+export declare function numberToBytes(value: number): Uint8Array;
+/**
+ * Convert a `string` to a UTF-8 encoded `Uint8Array`.
+ *
+ * @param value - The string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function stringToBytes(value: string): Uint8Array;
+/**
+ * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,
+ * a `bigint`, a `number`, or a `string`.
+ *
+ * If the value is a `string`, and it is prefixed with `0x`, it will be
+ * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a
+ * UTF-8 string. To convert a hexadecimal string to bytes without interpreting
+ * it as a UTF-8 string, use {@link hexToBytes} instead.
+ *
+ * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed
+ * `bigint` to bytes, use {@link signedBigIntToBytes} instead.
+ *
+ * If the value is a `Uint8Array`, it will be returned as-is.
+ *
+ * @param value - The value to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+export declare function valueToBytes(value: Bytes): Uint8Array;
+/**
+ * Concatenate multiple byte-like values into a single `Uint8Array`. The values
+ * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses
+ * {@link valueToBytes} under the hood to convert each value to bytes. Refer to
+ * the documentation of that function for more information.
+ *
+ * @param values - The values to concatenate.
+ * @returns The concatenated bytes as `Uint8Array`.
+ */
+export declare function concatBytes(values: Bytes[]): Uint8Array;

package/dist/bytes.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatBytes = exports.valueToBytes = exports.stringToBytes = exports.numberToBytes = exports.signedBigIntToBytes = exports.bigIntToBytes = exports.hexToBytes = exports.bytesToString = exports.bytesToNumber = exports.bytesToSignedBigInt = exports.bytesToBigInt = exports.bytesToHex = exports.assertIsBytes = exports.isBytes = void 0;
+const assert_1 = require("./assert");
+const hex_1 = require("./hex");
+// '0'.charCodeAt(0) === 48
+const HEX_MINIMUM_NUMBER_CHARACTER = 48;
+// '9'.charCodeAt(0) === 57
+const HEX_MAXIMUM_NUMBER_CHARACTER = 58;
+const HEX_CHARACTER_OFFSET = 87;
+/**
+ * Memoized function that returns an array to be used as a lookup table for
+ * converting bytes to hexadecimal values.
+ *
+ * The array is created lazily and then cached for future use. The benefit of
+ * this approach is that the performance of converting bytes to hex is much
+ * better than if we were to call `toString(16)` on each byte.
+ *
+ * The downside is that the array is created once and then never garbage
+ * collected. This is not a problem in practice because the array is only 256
+ * elements long.
+ *
+ * @returns A function that returns the lookup table.
+ */
+function getPrecomputedHexValuesBuilder() {
+    // To avoid issues with tree shaking, we need to use a function to return the
+    // array. This is because the array is only used in the `bytesToHex` function
+    // and if we were to use a global variable, the array might be removed by the
+    // tree shaker.
+    const lookupTable = [];
+    return () => {
+        if (lookupTable.length === 0) {
+            for (let i = 0; i < 256; i++) {
+                lookupTable.push(i.toString(16).padStart(2, '0'));
+            }
+        }
+        return lookupTable;
+    };
+}
+/**
+ * Function implementation of the {@link getPrecomputedHexValuesBuilder}
+ * function.
+ */
+const getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
+/**
+ * Check if a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `Uint8Array`.
+ */
+function isBytes(value) {
+    return value instanceof Uint8Array;
+}
+exports.isBytes = isBytes;
+/**
+ * Assert that a value is a `Uint8Array`.
+ *
+ * @param value - The value to check.
+ * @throws If the value is not a `Uint8Array`.
+ */
+function assertIsBytes(value) {
+    (0, assert_1.assert)(isBytes(value), 'Value must be a Uint8Array.');
+}
+exports.assertIsBytes = assertIsBytes;
+/**
+ * Convert a `Uint8Array` to a hexadecimal string.
+ *
+ * @param bytes - The bytes to convert to a hexadecimal string.
+ * @returns The hexadecimal string.
+ */
+function bytesToHex(bytes) {
+    assertIsBytes(bytes);
+    const lookupTable = getPrecomputedHexValues();
+    const hex = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        hex[i] = lookupTable[bytes[i]];
+    }
+    return (0, hex_1.add0x)(hex.join(''));
+}
+exports.bytesToHex = bytesToHex;
+/**
+ * Convert a `Uint8Array` to a `bigint`.
+ *
+ * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.
+ * To convert a two's complement encoded `Uint8Array` to a `bigint`, use
+ * {@link bytesToSignedBigInt}.
+ *
+ * @param bytes - The bytes to convert to a `bigint`.
+ * @returns The `bigint`.
+ */
+function bytesToBigInt(bytes) {
+    assertIsBytes(bytes);
+    const hex = bytesToHex(bytes);
+    return BigInt(hex);
+}
+exports.bytesToBigInt = bytesToBigInt;
+/**
+ * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are
+ * encoded in two's complement.
+ *
+ * To convert a `Uint8Array` to an unsigned `bigint` instead, use
+ * {@link bytesToBigInt}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param bytes - The bytes to convert to a signed `bigint`.
+ * @returns The signed `bigint`.
+ */
+function bytesToSignedBigInt(bytes) {
+    assertIsBytes(bytes);
+    let value = BigInt(0);
+    for (const byte of bytes) {
+        // eslint-disable-next-line no-bitwise
+        value = (value << BigInt(8)) + BigInt(byte);
+    }
+    return BigInt.asIntN(bytes.length * 8, value);
+}
+exports.bytesToSignedBigInt = bytesToSignedBigInt;
+/**
+ * Convert a `Uint8Array` to a `number`.
+ *
+ * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.
+ *
+ * @param bytes - The bytes to convert to a number.
+ * @returns The number.
+ * @throws If the resulting number is not a safe integer.
+ */
+function bytesToNumber(bytes) {
+    assertIsBytes(bytes);
+    const bigint = bytesToBigInt(bytes);
+    (0, assert_1.assert)(bigint <= BigInt(Number.MAX_SAFE_INTEGER), 'Number is not a safe integer. Use `bytesToBigInt` instead.');
+    return Number(bigint);
+}
+exports.bytesToNumber = bytesToNumber;
+/**
+ * Convert a UTF-8 encoded `Uint8Array` to a `string`.
+ *
+ * @param bytes - The bytes to convert to a string.
+ * @returns The string.
+ */
+function bytesToString(bytes) {
+    assertIsBytes(bytes);
+    return new TextDecoder(undefined).decode(bytes);
+}
+exports.bytesToString = bytesToString;
+/**
+ * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be
+ * prefixed with `0x`. It accepts even and odd length strings.
+ *
+ * @param value - The hexadecimal string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+function hexToBytes(value) {
+    (0, hex_1.assertIsHexString)(value);
+    // Remove the `0x` prefix if it exists, and pad the string to have an even
+    // number of characters.
+    const strippedValue = (0, hex_1.remove0x)(value).toLowerCase();
+    const normalizedValue = strippedValue.length % 2 === 0 ? strippedValue : `0${strippedValue}`;
+    const bytes = new Uint8Array(normalizedValue.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        // While this is not the prettiest way to convert a hexadecimal string to a
+        // `Uint8Array`, it is a lot faster than using `parseInt` to convert each
+        // character.
+        const c1 = normalizedValue.charCodeAt(i * 2);
+        const c2 = normalizedValue.charCodeAt(i * 2 + 1);
+        const n1 = c1 -
+            (c1 < HEX_MAXIMUM_NUMBER_CHARACTER
+                ? HEX_MINIMUM_NUMBER_CHARACTER
+                : HEX_CHARACTER_OFFSET);
+        const n2 = c2 -
+            (c2 < HEX_MAXIMUM_NUMBER_CHARACTER
+                ? HEX_MINIMUM_NUMBER_CHARACTER
+                : HEX_CHARACTER_OFFSET);
+        bytes[i] = n1 * 16 + n2;
+    }
+    return bytes;
+}
+exports.hexToBytes = hexToBytes;
+/**
+ * Convert a `bigint` to a `Uint8Array`.
+ *
+ * This assumes that the `bigint` is an unsigned integer. To convert a signed
+ * `bigint` instead, use {@link signedBigIntToBytes}.
+ *
+ * @param value - The bigint to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+function bigIntToBytes(value) {
+    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, assert_1.assert)(value >= BigInt(0), 'Value must be a non-negative bigint.');
+    const hex = value.toString(16);
+    return hexToBytes(hex);
+}
+exports.bigIntToBytes = bigIntToBytes;
+/**
+ * Check if a `bigint` fits in a certain number of bytes.
+ *
+ * @param value - The `bigint` to check.
+ * @param bytes - The number of bytes.
+ * @returns Whether the `bigint` fits in the number of bytes.
+ */
+function bigIntFits(value, bytes) {
+    (0, assert_1.assert)(bytes > 0);
+    /* eslint-disable no-bitwise */
+    const mask = value >> BigInt(31);
+    return !(((~value & mask) + (value & ~mask)) >> BigInt(bytes * 8 + ~0));
+    /* eslint-enable no-bitwise */
+}
+/**
+ * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement
+ * encoding to represent negative numbers.
+ *
+ * To convert an unsigned `bigint` to a `Uint8Array` instead, use
+ * {@link bigIntToBytes}.
+ *
+ * @see https://en.wikipedia.org/wiki/Two%27s_complement
+ * @param value - The number to convert to bytes.
+ * @param byteLength - The length of the resulting `Uint8Array`. If the number
+ * is larger than the maximum value that can be represented by the given length,
+ * an error is thrown.
+ * @returns The bytes as `Uint8Array`.
+ */
+function signedBigIntToBytes(value, byteLength) {
+    (0, assert_1.assert)(typeof value === 'bigint', 'Value must be a bigint.');
+    (0, assert_1.assert)(typeof byteLength === 'number', 'Byte length must be a number.');
+    (0, assert_1.assert)(byteLength > 0, 'Byte length must be greater than 0.');
+    (0, assert_1.assert)(bigIntFits(value, byteLength), 'Byte length is too small to represent the given value.');
+    // ESLint doesn't like mutating function parameters, so to avoid having to
+    // disable the rule, we create a new variable.
+    let numberValue = value;
+    const bytes = new Uint8Array(byteLength);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Number(BigInt.asUintN(8, numberValue));
+        // eslint-disable-next-line no-bitwise
+        numberValue >>= BigInt(8);
+    }
+    return bytes.reverse();
+}
+exports.signedBigIntToBytes = signedBigIntToBytes;
+/**
+ * Convert a `number` to a `Uint8Array`.
+ *
+ * @param value - The number to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ * @throws If the number is not a safe integer.
+ */
+function numberToBytes(value) {
+    (0, assert_1.assert)(typeof value === 'number', 'Value must be a number.');
+    (0, assert_1.assert)(value >= 0, 'Value must be a non-negative number.');
+    (0, assert_1.assert)(Number.isSafeInteger(value), 'Value is not a safe integer. Use `bigIntToBytes` instead.');
+    const hex = value.toString(16);
+    return hexToBytes(hex);
+}
+exports.numberToBytes = numberToBytes;
+/**
+ * Convert a `string` to a UTF-8 encoded `Uint8Array`.
+ *
+ * @param value - The string to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+function stringToBytes(value) {
+    (0, assert_1.assert)(typeof value === 'string', 'Value must be a string.');
+    return new TextEncoder().encode(value);
+}
+exports.stringToBytes = stringToBytes;
+/**
+ * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,
+ * a `bigint`, a `number`, or a `string`.
+ *
+ * If the value is a `string`, and it is prefixed with `0x`, it will be
+ * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a
+ * UTF-8 string. To convert a hexadecimal string to bytes without interpreting
+ * it as a UTF-8 string, use {@link hexToBytes} instead.
+ *
+ * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed
+ * `bigint` to bytes, use {@link signedBigIntToBytes} instead.
+ *
+ * If the value is a `Uint8Array`, it will be returned as-is.
+ *
+ * @param value - The value to convert to bytes.
+ * @returns The bytes as `Uint8Array`.
+ */
+function valueToBytes(value) {
+    if (typeof value === 'bigint') {
+        return bigIntToBytes(value);
+    }
+    if (typeof value === 'number') {
+        return numberToBytes(value);
+    }
+    if (typeof value === 'string') {
+        if (value.startsWith('0x')) {
+            return hexToBytes(value);
+        }
+        return stringToBytes(value);
+    }
+    if (isBytes(value)) {
+        return value;
+    }
+    throw new TypeError(`Unsupported value type: "${typeof value}".`);
+}
+exports.valueToBytes = valueToBytes;
+/**
+ * Concatenate multiple byte-like values into a single `Uint8Array`. The values
+ * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses
+ * {@link valueToBytes} under the hood to convert each value to bytes. Refer to
+ * the documentation of that function for more information.
+ *
+ * @param values - The values to concatenate.
+ * @returns The concatenated bytes as `Uint8Array`.
+ */
+function concatBytes(values) {
+    const normalizedValues = new Array(values.length);
+    let byteLength = 0;
+    for (let i = 0; i < values.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const value = valueToBytes(values[i]);
+        normalizedValues[i] = value;
+        byteLength += value.length;
+    }
+    const bytes = new Uint8Array(byteLength);
+    for (let i = 0, offset = 0; i < normalizedValues.length; i++) {
+        // While we could simply spread the values into an array and use
+        // `Uint8Array.from`, that is a lot slower than using `Uint8Array.set`.
+        bytes.set(normalizedValues[i], offset);
+        offset += normalizedValues[i].length;
+    }
+    return bytes;
+}
+exports.concatBytes = concatBytes;
+//# sourceMappingURL=bytes.js.map

package/dist/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../src/bytes.ts"],"names":[],"mappings":"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","sourcesContent":["import { assert } from './assert';\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): string {\n  assertIsBytes(bytes);\n\n  const lookupTable = getPrecomputedHexValues();\n  const hex = 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    hex[i] = lookupTable[bytes[i]!];\n  }\n\n  return add0x(hex.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 hex = bytesToHex(bytes);\n  return BigInt(hex);\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(undefined).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 * @param value - The hexadecimal string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function hexToBytes(value: string): Uint8Array {\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 hex = value.toString(16);\n  return hexToBytes(hex);\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 hex = value.toString(16);\n  return hexToBytes(hex);\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 * 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"]}

package/dist/hex.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Add the `0x`-prefix to a hexadecimal string. If the string already has the
+ * prefix, it is returned as-is.
+ *
+ * @param hex - The hexadecimal string to add the prefix to.
+ * @returns The prefixed hexadecimal string.
+ */
+export declare function add0x(hex: string): string;
+/**
+ * Remove the `0x`-prefix from a hexadecimal string. If the string doesn't have
+ * the prefix, it is returned as-is.
+ *
+ * @param hex - The hexadecimal string to remove the prefix from.
+ * @returns The un-prefixed hexadecimal string.
+ */
+export declare function remove0x(hex: string): string;