@feelyourprotocol/util 8141.0.0

package/dist/cjs/blobs.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blobsToCellProofs = exports.blobsToCellsAndProofs = exports.blobsToCells = exports.commitmentsToVersionedHashes = exports.computeVersionedHash = exports.blobsToProofs = exports.blobsToCommitments = exports.getBlobs = exports.CELLS_PER_EXT_BLOB = void 0;
+exports.getBlob = getBlob;
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const bytes_ts_1 = require("./bytes.js");
+/**
+ * These utilities for constructing blobs are borrowed from https://github.com/Inphi/eip4844-interop.git
+ */
+const BYTES_PER_FIELD_ELEMENT = 32; // EIP-4844
+const FIELD_ELEMENTS_PER_BLOB = 4096; // EIP-4844
+const BLOB_SIZE = BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB;
+const MAX_BLOBS_PER_TX = 6; // EIP-7691: Blob throughput increase, Pectra HF
+const MAX_BLOB_BYTES_PER_TX = BLOB_SIZE * MAX_BLOBS_PER_TX - 1;
+exports.CELLS_PER_EXT_BLOB = 128; // EIP-4844, Consensus Spec, 2 * FIELD_ELEMENTS_PER_BLOB // 64 (FIELD_ELEMENTS_PER_CELL)
+/**
+ * Pads input data to blob boundaries with 0x80 marker and zeros.
+ * @param data Input data to pad
+ * @param blobs_len Number of blobs the data should span
+ * @returns Padded data aligned to blob boundaries
+ */
+function getPadded(data, blobs_len) {
+    const pData = new Uint8Array(blobs_len * BLOB_SIZE);
+    pData.set(data);
+    pData[data.byteLength] = 0x80;
+    return pData;
+}
+/**
+ * Converts arbitrary byte data into EIP-4844 blob format.
+ * Splits data into 4096 field elements of 32 bytes each, with proper alignment.
+ * @param data Input data (must be exactly BLOB_SIZE bytes)
+ * @returns Hex-prefixed blob string
+ */
+function getBlob(data) {
+    const blob = new Uint8Array(BLOB_SIZE);
+    for (let i = 0; i < FIELD_ELEMENTS_PER_BLOB; i++) {
+        const chunk = new Uint8Array(32);
+        chunk.set(data.subarray(i * 31, (i + 1) * 31), 0);
+        blob.set(chunk, i * 32);
+    }
+    return (0, bytes_ts_1.bytesToHex)(blob);
+}
+/**
+ * EIP-4844: Converts UTF-8 string(s) into EIP-4844 blob format.
+ *
+ * Each input string is converted to UTF-8 bytes, padded with 0x80 followed by zeros
+ * to align with blob boundaries, and encoded as one or more blobs depending on size.
+ * Multiple inputs are processed sequentially, with each input contributing its own blob(s).
+ *
+ * @param input Single UTF-8 string or array of UTF-8 strings to encode
+ * @throws Error with message 'invalid blob data' if any input string is empty
+ * @throws Error with message 'blob data is too large' if any single input exceeds MAX_USEFUL_BYTES_PER_TX
+ * @returns Array of hex-prefixed blob strings (0x...), one blob per 131,071 useful bytes per input
+ */
+const getBlobs = (input) => {
+    const inputArray = Array.isArray(input) ? input : [input];
+    const blobs = [];
+    for (const input of inputArray) {
+        const data = (0, bytes_ts_1.utf8ToBytes)(input);
+        const len = data.byteLength;
+        if (len === 0) {
+            throw Error('invalid blob data (0 bytes)');
+        }
+        if (len > MAX_BLOB_BYTES_PER_TX) {
+            throw Error(`blob data is too large (${len} bytes > ${MAX_BLOB_BYTES_PER_TX} bytes)`);
+        }
+        const blobs_len = Math.ceil(len / BLOB_SIZE);
+        const pData = getPadded(data, blobs_len);
+        for (let i = 0; i < blobs_len; i++) {
+            const chunk = pData.subarray(i * BLOB_SIZE, (i + 1) * BLOB_SIZE);
+            const blob = getBlob(chunk);
+            blobs.push(blob);
+        }
+    }
+    return blobs;
+};
+exports.getBlobs = getBlobs;
+/**
+ * EIP-4844: Computes KZG commitments for a set of blobs.
+ * @param kzg KZG implementation used to compute commitments
+ * @param blobs Array of blob data as hex-prefixed strings
+ * @returns Array of lowercase hex-prefixed KZG commitments (one per blob)
+ */
+const blobsToCommitments = (kzg, blobs) => {
+    const commitments = [];
+    for (const blob of blobs) {
+        commitments.push(kzg.blobToKzgCommitment(blob).toLowerCase());
+    }
+    return commitments;
+};
+exports.blobsToCommitments = blobsToCommitments;
+/**
+ * EIP-4844: Computes KZG proofs for each blob/commitment pair.
+ * @param kzg KZG implementation used to compute proofs
+ * @param blobs Array of blob data as hex-prefixed strings
+ * @param commitments Array of corresponding blob commitments
+ * @returns Array of lowercase hex-prefixed proofs (aligned with input order)
+ */
+const blobsToProofs = (kzg, blobs, commitments) => {
+    const proofs = blobs.map((blob, ctx) => kzg.computeBlobProof(blob, commitments[ctx]).toLowerCase());
+    return proofs;
+};
+exports.blobsToProofs = blobsToProofs;
+/**
+ * EIP-4844: Converts a vector commitment for a given data blob to its versioned hash.  For 4844, this version
+ * number will be 0x01 for KZG vector commitments but could be different if future vector commitment
+ * types are introduced
+ * @param commitment a vector commitment to a blob
+ * @param blobCommitmentVersion the version number corresponding to the type of vector commitment
+ * @returns a versioned hash corresponding to a given blob vector commitment
+ */
+const computeVersionedHash = (commitment, blobCommitmentVersion) => {
+    const computedVersionedHash = new Uint8Array(32);
+    computedVersionedHash.set([blobCommitmentVersion], 0);
+    computedVersionedHash.set((0, sha2_js_1.sha256)((0, bytes_ts_1.hexToBytes)(commitment)).subarray(1), 1);
+    return (0, bytes_ts_1.bytesToHex)(computedVersionedHash);
+};
+exports.computeVersionedHash = computeVersionedHash;
+/**
+ * EIP-4844: Generate an array of versioned hashes from corresponding kzg commitments
+ * @param commitments array of kzg commitments
+ * @returns array of versioned hashes
+ * Note: assumes KZG commitments (version 1 version hashes)
+ */
+const commitmentsToVersionedHashes = (commitments) => {
+    const hashes = [];
+    for (const commitment of commitments) {
+        hashes.push((0, exports.computeVersionedHash)(commitment, 0x01));
+    }
+    return hashes;
+};
+exports.commitmentsToVersionedHashes = commitmentsToVersionedHashes;
+/**
+ * EIP-7594: Expands blobs into their extended cells using the provided KZG implementation.
+ * @param kzg KZG implementation capable of computing cells
+ * @param blobs Array of blob data as hex-prefixed strings
+ * @returns Tuple of [cells, indices], where cells are hex strings and indices are 0..127
+ */
+const blobsToCells = (kzg, blobs) => {
+    const cells = blobs.reduce((acc, elem) => {
+        return [...acc, ...kzg.computeCells(elem)];
+    }, []);
+    const indices = Array.from({ length: exports.CELLS_PER_EXT_BLOB }, (_, i) => i);
+    return [cells, indices];
+};
+exports.blobsToCells = blobsToCells;
+/**
+ * EIP-7594: Computes extended cells and corresponding proofs for the given blobs.
+ * @param kzg KZG implementation capable of computing cells and proofs
+ * @param blobs Array of blob data as hex-prefixed strings
+ * @returns Tuple of [cells, proofs, indices]; indices are 0..127
+ */
+const blobsToCellsAndProofs = (kzg, blobs) => {
+    const blobsAndCells = blobs.reduce(([cellsAcc, proofsAcc], elem) => {
+        const blobCellsAndProofs = kzg.computeCellsAndProofs(elem);
+        return [
+            [...cellsAcc, ...blobCellsAndProofs[0]],
+            [...proofsAcc, ...blobCellsAndProofs[1]],
+        ];
+    }, [[], []]);
+    const indices = Array.from({ length: exports.CELLS_PER_EXT_BLOB }, (_, i) => i);
+    return [...blobsAndCells, indices];
+};
+exports.blobsToCellsAndProofs = blobsToCellsAndProofs;
+/**
+ * EIP-7594: Computes cell proofs for the given blobs.
+ * @param kzg KZG implementation capable of computing cell proofs
+ * @param blobs Array of blob data as hex-prefixed strings
+ * @returns Array of lowercase hex-prefixed cell proofs (aligned with input order)
+ */
+const blobsToCellProofs = (kzg, blobs) => {
+    return (0, exports.blobsToCellsAndProofs)(kzg, blobs)[1];
+};
+exports.blobsToCellProofs = blobsToCellProofs;
+//# sourceMappingURL=blobs.js.map

package/dist/cjs/blobs.js.map

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

package/dist/cjs/bytes.d.ts

@@ -0,0 +1,291 @@
+import { bytesToHex as bytesToUnprefixedHexNoble } from '@noble/hashes/utils.js';
+import type { PrefixedHexString, TransformableToBytes } from './types.ts';
+/**
+ * @deprecated
+ */
+export declare const bytesToUnprefixedHex: typeof bytesToUnprefixedHexNoble;
+/**
+ * Converts a {@link PrefixedHexString} to a {@link Uint8Array}
+ * @param {PrefixedHexString} hex The 0x-prefixed hex string to convert
+ * @returns {Uint8Array} The converted bytes
+ * @throws If the input is not a valid 0x-prefixed hex string
+ */
+export declare const hexToBytes: (hex: PrefixedHexString) => Uint8Array;
+export declare const unprefixedHexToBytes: (hex: string) => Uint8Array;
+/**
+ * Converts a {@link Uint8Array} to a {@link PrefixedHexString}
+ * @param {Uint8Array} bytes the bytes to convert
+ * @returns {PrefixedHexString} the hex string
+ * @dev Returns `0x` if provided an empty Uint8Array
+ */
+export declare const bytesToHex: (bytes: Uint8Array) => PrefixedHexString;
+/**
+ * Converts a {@link Uint8Array} to a {@link bigint}
+ * @param {Uint8Array} bytes the bytes to convert
+ * @returns {bigint}
+ */
+export declare const bytesToBigInt: (bytes: Uint8Array, littleEndian?: boolean) => bigint;
+/**
+ * Converts a {@link Uint8Array} to a {@link number}.
+ * @param {Uint8Array} bytes the bytes to convert
+ * @return  {number}
+ * @throws If the input number exceeds 53 bits.
+ */
+export declare const bytesToInt: (bytes: Uint8Array) => number;
+/******************************************/
+/**
+ * Converts a {@link number} into a {@link PrefixedHexString}
+ * @param {number} i
+ * @return {PrefixedHexString}
+ */
+export declare const intToHex: (i: number) => PrefixedHexString;
+/**
+ * Converts an {@link number} to a {@link Uint8Array}
+ * @param {Number} i
+ * @return {Uint8Array}
+ */
+export declare const intToBytes: (i: number) => Uint8Array;
+/**
+ * Converts a {@link bigint} to a {@link Uint8Array}
+ *  * @param {bigint} num the bigint to convert
+ * @returns {Uint8Array}
+ */
+export declare const bigIntToBytes: (num: bigint, littleEndian?: boolean) => Uint8Array;
+export interface SetLengthOpts {
+    /** Allow truncation if msg exceeds length. Default: false */
+    allowTruncate?: boolean;
+}
+/**
+ * Left Pads a `Uint8Array` with leading zeros till it has `length` bytes.
+ * Throws if input length exceeds target length, unless allowTruncate option is true.
+ * @param {Uint8Array} msg the value to pad
+ * @param {number} length the number of bytes the output should be
+ * @param {SetLengthOpts} opts options object with allowTruncate flag
+ * @return {Uint8Array}
+ */
+export declare const setLengthLeft: (msg: Uint8Array, length: number, opts?: SetLengthOpts) => Uint8Array;
+/**
+ * Right Pads a `Uint8Array` with trailing zeros till it has `length` bytes.
+ * Throws if input length exceeds target length, unless allowTruncate option is true.
+ * @param {Uint8Array} msg the value to pad
+ * @param {number} length the number of bytes the output should be
+ * @param {SetLengthOpts} opts options object with allowTruncate flag
+ * @return {Uint8Array}
+ */
+export declare const setLengthRight: (msg: Uint8Array, length: number, opts?: SetLengthOpts) => Uint8Array;
+/**
+ * Trims leading zeros from a `Uint8Array`.
+ * @param {Uint8Array} a
+ * @return {Uint8Array}
+ */
+export declare const unpadBytes: (a: Uint8Array) => Uint8Array;
+/**
+ * Trims leading zeros from an `Array` (of numbers).
+ * @param  {number[]} a
+ * @return {number[]}
+ */
+export declare const unpadArray: (a: number[]) => number[];
+/**
+ * Trims leading zeros from a `PrefixedHexString`.
+ * @param {PrefixedHexString} a
+ * @return {PrefixedHexString}
+ */
+export declare const unpadHex: (a: PrefixedHexString) => PrefixedHexString;
+export type ToBytesInputTypes = PrefixedHexString | number | bigint | Uint8Array | number[] | TransformableToBytes | null | undefined;
+/**
+ * Attempts to turn a value into a `Uint8Array`.
+ * Inputs supported: `Buffer`, `Uint8Array`, `String` (hex-prefixed), `Number`, null/undefined, `BigInt` and other objects
+ * with a `toArray()` or `toBytes()` method.
+ * @param {ToBytesInputTypes} v the value
+ * @return {Uint8Array}
+ */
+export declare const toBytes: (v: ToBytesInputTypes) => Uint8Array;
+/**
+ * Interprets a `Uint8Array` as a signed integer and returns a `BigInt`. Assumes 256-bit numbers.
+ * @param {Uint8Array} num Signed integer value
+ * @returns {bigint}
+ */
+export declare const fromSigned: (num: Uint8Array) => bigint;
+/**
+ * Converts a `BigInt` to an unsigned integer and returns it as a `Uint8Array`. Assumes 256-bit numbers.
+ * @param {bigint} num
+ * @returns {Uint8Array}
+ */
+export declare const toUnsigned: (num: bigint) => Uint8Array;
+/**
+ * Adds "0x" to a given `string` if it does not already start with "0x".
+ * @param {string} str
+ * @return {PrefixedHexString}
+ */
+export declare const addHexPrefix: (str: string) => PrefixedHexString;
+/**
+ * Shortens a string  or Uint8Array's hex string representation to maxLength (default 50).
+ *
+ * Examples:
+ *
+ * Input:  '657468657265756d000000000000000000000000000000000000000000000000'
+ * Output: '657468657265756d0000000000000000000000000000000000…'
+ * @param {Uint8Array | string} bytes
+ * @param {number} maxLength
+ * @return {string}
+ */
+export declare const short: (bytes: Uint8Array | string, maxLength?: number) => string;
+/**
+ * Checks provided Uint8Array for leading zeroes and throws if found.
+ *
+ * Examples:
+ *
+ * Valid values: 0x1, 0x, 0x01, 0x1234
+ * Invalid values: 0x0, 0x00, 0x001, 0x0001
+ *
+ * Note: This method is useful for validating that RLP encoded integers comply with the rule that all
+ * integer values encoded to RLP must be in the most compact form and contain no leading zero bytes
+ * @param values An object containing string keys and Uint8Array values
+ * @throws if any provided value is found to have leading zero bytes
+ */
+export declare const validateNoLeadingZeroes: (values: {
+    [key: string]: Uint8Array | undefined;
+}) => void;
+/**
+ * Converts a {@link bigint} to a `0x` prefixed hex string
+ * @param {bigint} num the bigint to convert
+ * @returns {PrefixedHexString}
+ */
+export declare const bigIntToHex: (num: bigint) => PrefixedHexString;
+/**
+ * Calculates max bigint from an array of bigints
+ * @param args array of bigints
+ */
+export declare const bigIntMax: (...args: bigint[]) => bigint;
+/**
+ * Calculates min BigInt from an array of BigInts
+ * @param args array of bigints
+ */
+export declare const bigIntMin: (...args: bigint[]) => bigint;
+/**
+ * Convert value from bigint to an unpadded Uint8Array
+ * (useful for RLP transport)
+ * @param {bigint} value the bigint to convert
+ * @returns {Uint8Array}
+ */
+export declare const bigIntToUnpaddedBytes: (value: bigint) => Uint8Array;
+export declare const bigIntToAddressBytes: (value: bigint, strict?: boolean) => Uint8Array;
+/**
+ * Convert value from number to an unpadded Uint8Array
+ * (useful for RLP transport)
+ * @param {number} value the bigint to convert
+ * @returns {Uint8Array}
+ */
+export declare const intToUnpaddedBytes: (value: number) => Uint8Array;
+/**
+ * Compares two Uint8Arrays and returns a number indicating their order in a sorted array.
+ *
+ * @param {Uint8Array} value1 - The first Uint8Array to compare.
+ * @param {Uint8Array} value2 - The second Uint8Array to compare.
+ * @returns {number} A positive number if value1 is larger than value2,
+ *                   A negative number if value1 is smaller than value2,
+ *                   or 0 if value1 and value2 are equal.
+ */
+export declare const compareBytes: (value1: Uint8Array, value2: Uint8Array) => number;
+/**
+ * Generates a Uint8Array of random bytes of specified length.
+ *
+ * @param {number} length - The length of the Uint8Array.
+ * @returns {Uint8Array} A Uint8Array of random bytes of specified length.
+ */
+export declare const randomBytes: (length: number) => Uint8Array;
+/**
+ * This mirrors the functionality of the `ethereum-cryptography` export except
+ * it skips the check to validate that every element of `arrays` is indeed a `uint8Array`
+ * Can give small performance gains on large arrays
+ * @param {Uint8Array[]} arrays an array of Uint8Arrays
+ * @returns {Uint8Array} one Uint8Array with all the elements of the original set
+ * works like `Buffer.concat`
+ */
+export declare const concatBytes: (...arrays: Uint8Array[]) => Uint8Array<ArrayBuffer>;
+/**
+ * @notice Convert a Uint8Array to a 32-bit integer
+ * @param {Uint8Array} bytes The input Uint8Array from which to read the 32-bit integer.
+ * @param {boolean} littleEndian True for little-endian, undefined or false for big-endian.
+ * @return {number} The 32-bit integer read from the input Uint8Array.
+ */
+export declare function bytesToInt32(bytes: Uint8Array, littleEndian?: boolean): number;
+/**
+ * @notice Convert a Uint8Array to a 64-bit bigint
+ * @param {Uint8Array} bytes The input Uint8Array from which to read the 64-bit bigint.
+ * @param {boolean} littleEndian True for little-endian, undefined or false for big-endian.
+ * @return {bigint} The 64-bit bigint read from the input Uint8Array.
+ */
+export declare function bytesToBigInt64(bytes: Uint8Array, littleEndian?: boolean): bigint;
+/**
+ * @notice Convert a 32-bit integer to a Uint8Array.
+ * @param {number} value The 32-bit integer to convert.
+ * @param {boolean} littleEndian True for little-endian, undefined or false for big-endian.
+ * @return {Uint8Array} A Uint8Array of length 4 containing the integer.
+ */
+export declare function int32ToBytes(value: number, littleEndian?: boolean): Uint8Array;
+/**
+ * @notice Convert a 64-bit bigint to a Uint8Array.
+ * @param {bigint} value The 64-bit bigint to convert.
+ * @param {boolean} littleEndian True for little-endian, undefined or false for big-endian.
+ * @return {Uint8Array} A Uint8Array of length 8 containing the bigint.
+ */
+export declare function bigInt64ToBytes(value: bigint, littleEndian?: boolean): Uint8Array;
+export { utf8ToBytes } from '@noble/hashes/utils.js';
+/**
+ * @notice Converts a Uint8Array to a UTF-8 string.
+ * Implementation copied from ethereum-cryptography https://github.com/ethereum/js-ethereum-cryptography/blob/31f980b2847545d33268f2510ba38a3836202a44/src/utils.ts#L22-L27
+ * @param {Uint8Array} bytes - The input Uint8Array to convert.
+ * @returns {string} The UTF-8 string.
+ * @throws {TypeError} If the input is not a Uint8Array.
+ *
+ */
+export declare function bytesToUtf8(bytes: Uint8Array): string;
+/**
+ * @notice Compares two Uint8Arrays and returns true if they are equal.
+ * Implementation copied from ethereum-cryptography https://github.com/ethereum/js-ethereum-cryptography/blob/main/src/utils.ts#L35-L45
+ * @param {Uint8Array} a - The first Uint8Array to compare.
+ * @param {Uint8Array} b - The second Uint8Array to compare.
+ * @returns {boolean} True if the Uint8Arrays are equal, false otherwise.
+ */
+export declare function equalsBytes(a: Uint8Array, b: Uint8Array): boolean;
+export declare function hexToBigInt(input: PrefixedHexString): bigint;
+/**
+ * Converts a Uint8Array of bytes into an array of bits.
+ * @param {Uint8Array} bytes - The input byte array.
+ * @param {number} bitLength - The number of bits to extract from the input bytes.
+ * @returns {number[]} An array of bits (each 0 or 1) corresponding to the input bytes.
+ */
+export declare function bytesToBits(bytes: Uint8Array, bitLength?: number): number[];
+/**
+ * Converts an array of bits into a Uint8Array.
+ * The input bits are grouped into sets of 8, with the first bit in each group being the most significant.
+ * @param {number[]} bits - The input array of bits (each should be 0 or 1). Its length should be a multiple of 8.
+ * @returns {Uint8Array} A Uint8Array constructed from the input bits.
+ */
+export declare function bitsToBytes(bits: number[]): Uint8Array;
+/**
+ * Compares two byte arrays and returns the count of consecutively matching items from the start.
+ * @param {Uint8Array} bytes1 - The first Uint8Array to compare.
+ * @param {Uint8Array} bytes2 - The second Uint8Array to compare.
+ * @returns {number} The count of consecutively matching items from the start.
+ */
+export declare function matchingBytesLength(bytes1: Uint8Array, bytes2: Uint8Array): number;
+/**
+ * Compares two arrays of bits (0 or 1) and returns the count of consecutively matching bits from the start.
+ * @param {number[]} bits1 - The first array of bits, in bytes or bits.
+ * @param {number[]} bits2 - The second array of bits, in bytes or bits.
+ * @returns {number} The count of consecutively matching bits from the start.
+ */
+export declare function matchingBitsLength(bits1: number[], bits2: number[]): number;
+/**
+ * Checks whether two arrays of bits are equal.
+ *
+ * Two arrays are considered equal if they have the same length and each corresponding element is identical.
+ *
+ * @param {number[]} bits1 - The first bits array.
+ * @param {number[]} bits2 - The second bits array.
+ * @returns {boolean} True if the arrays are equal; otherwise, false.
+ */
+export declare function equalsBits(bits1: number[], bits2: number[]): boolean;
+//# sourceMappingURL=bytes.d.ts.map

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

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