@feelyourprotocol/util 8141.0.0

package/dist/esm/binaryTree.d.ts

@@ -0,0 +1,148 @@
+import type { Account } from './account.ts';
+import type { Address } from './address.ts';
+import type { PrefixedHexString } from './types.ts';
+/**
+ * @dev Returns the 31-bytes binary tree stem for a given address and tree index.
+ * @param hashFunction The hashFunction for the binary tree
+ * @param {Address} address The address to generate the tree key for.
+ * @param treeIndex The index of the tree to generate the key for. Defaults to 0.
+ * @return The 31-bytes binary tree stem as a Uint8Array.
+ */
+export declare function getBinaryTreeStem(hashFunction: (value: Uint8Array) => Uint8Array, address: Address, treeIndex?: number | bigint): Uint8Array;
+export interface BinaryTreeStateDiff {
+    stem: PrefixedHexString;
+    suffixDiffs: {
+        currentValue: PrefixedHexString | null;
+        newValue: PrefixedHexString | null;
+        suffix: number | string;
+    }[];
+}
+export type BinaryTreeProof = any;
+/**
+ * Experimental, object format could eventual change.
+ * An object that provides the state and proof necessary for binary tree stateless execution
+ * */
+export interface BinaryTreeExecutionWitness {
+    /**
+     * The stateRoot of the parent block
+     */
+    parentStateRoot: PrefixedHexString;
+    /**
+     * An array of state diffs.
+     * Each item corresponding to state accesses or state modifications of the block.
+     * In the current design, it also contains the resulting state of the block execution (post-state).
+     */
+    stateDiff: BinaryTreeStateDiff[];
+    /**
+     * The proof for the block.
+     * Proves that the provided stateDiff belongs to the canonical binary tree.
+     */
+    proof: BinaryTreeProof;
+}
+export type BinaryTreeLeafType = (typeof BinaryTreeLeafType)[keyof typeof BinaryTreeLeafType];
+export declare const BinaryTreeLeafType: {
+    readonly BasicData: 0;
+    readonly CodeHash: 1;
+};
+export type BinaryTreeLeafBasicData = {
+    version: number;
+    nonce: bigint;
+    balance: bigint;
+    codeSize: number;
+};
+export declare const BINARY_TREE_VERSION_OFFSET = 0;
+export declare const BINARY_TREE_CODE_SIZE_OFFSET = 5;
+export declare const BINARY_TREE_NONCE_OFFSET = 8;
+export declare const BINARY_TREE_BALANCE_OFFSET = 16;
+export declare const BINARY_TREE_VERSION_BYTES_LENGTH = 1;
+export declare const BINARY_TREE_CODE_SIZE_BYTES_LENGTH = 3;
+export declare const BINARY_TREE_NONCE_BYTES_LENGTH = 8;
+export declare const BINARY_TREE_BALANCE_BYTES_LENGTH = 16;
+export declare const BINARY_TREE_BASIC_DATA_LEAF_KEY: Uint8Array<ArrayBufferLike>;
+export declare const BINARY_TREE_CODE_HASH_LEAF_KEY: Uint8Array<ArrayBufferLike>;
+export declare const BINARY_TREE_CODE_CHUNK_SIZE = 31;
+export declare const BINARY_TREE_HEADER_STORAGE_OFFSET = 64;
+export declare const BINARY_TREE_CODE_OFFSET = 128;
+export declare const BINARY_TREE_NODE_WIDTH = 256;
+export declare const BINARY_TREE_MAIN_STORAGE_OFFSET: bigint;
+/**
+ * @dev Returns the tree key for a given binary tree stem, and sub index.
+ * @dev Assumes that the tree node width = 256
+ * @param stem The 31-bytes binary tree stem as a Uint8Array.
+ * @param subIndex The sub index of the tree to generate the key for as a Uint8Array.
+ * @return The tree key as a Uint8Array.
+ */
+export declare const getBinaryTreeKey: (stem: Uint8Array, leaf: BinaryTreeLeafType | Uint8Array) => Uint8Array<ArrayBuffer>;
+/**
+ * Calculates the position of the storage key in the BinaryTree tree, determining
+ * both the tree index (the node in the tree) and the subindex (the position within the node).
+ * @param {bigint} storageKey - The key representing a specific storage slot.
+ * @returns {Object} - An object containing the tree index and subindex
+ */
+export declare function getBinaryTreeIndicesForStorageSlot(storageKey: bigint): {
+    treeIndex: bigint;
+    subIndex: number;
+};
+/**
+ * Calculates the position of the code chunks in the BinaryTree tree, determining
+ * both the tree index (the node in the tree) and the subindex (the position within the node).
+ * @param {bigint} chunkId - The ID representing a specific chunk.
+ * @returns {Object} - An object containing the tree index and subindex
+ */
+export declare function getBinaryTreeIndicesForCodeChunk(chunkId: number): {
+    treeIndex: number;
+    subIndex: number;
+};
+/**
+ * Asynchronously calculates the BinaryTree tree key for the specified code chunk ID.
+ * @param {Address} address - The account address to access code for.
+ * @param {number} chunkId - The ID of the code chunk to retrieve.
+ * @param hashFunction - The hash function used for BinaryTree-related operations.
+ * @returns {Uint8Array} - The BinaryTree tree key as a byte array.
+ */
+export declare const getBinaryTreeKeyForCodeChunk: (address: Address, chunkId: number, hashFunction: (input: Uint8Array) => Uint8Array) => Uint8Array<ArrayBuffer>;
+export declare const chunkifyBinaryTreeCode: (code: Uint8Array) => Uint8Array<ArrayBufferLike>[];
+/**
+ * Asynchronously calculates the BinaryTree tree key for the specified storage slot.
+ * @param {Address} address - The account address to access code for.
+ * @param {bigint} storageKey - The storage slot key to retrieve the key for.
+ * @param hashFunction - The hash function used in the Binary Tree.
+ * @returns {Uint8Array} - The BinaryTree tree key as a byte array.
+ */
+export declare const getBinaryTreeKeyForStorageSlot: (address: Address, storageKey: bigint, hashFunction: (input: Uint8Array) => Uint8Array) => Uint8Array<ArrayBuffer>;
+/**
+ * This function extracts and decodes account header elements (version, nonce, code size, and balance)
+ * from an encoded `Uint8Array` representation of raw BinaryTree leaf-node basic data. Each component is sliced
+ * from the `encodedBasicData` array based on predefined offsets and lengths, and then converted
+ * to its appropriate type (integer or BigInt).
+ * @param {Uint8Array} encodedBasicData - The encoded BinaryTree leaf basic data containing the version, nonce,
+ * code size, and balance in a compact Uint8Array format.
+ * @returns {BinaryTreeLeafBasicData} - An object containing the decoded version, nonce, code size, and balance.
+ */
+export declare function decodeBinaryTreeLeafBasicData(encodedBasicData: Uint8Array): BinaryTreeLeafBasicData;
+/**
+ * This function takes a `BinaryTreeLeafBasicData` object and encodes its properties
+ * (version, nonce, code size, and balance) into a compact `Uint8Array` format. Each
+ * property is serialized and padded to match the required byte lengths defined by
+ * EIP-7864. Additionally, 4 bytes are reserved for future use as specified
+ * in EIP-7864.
+ * @param {Account} account - An object containing the version, nonce,
+ *   code size, and balance to be encoded.
+ * @returns {Uint8Array} - A compact bytes representation of the account header basic data.
+ */
+export declare function encodeBinaryTreeLeafBasicData(account: Account): Uint8Array;
+/**
+ * Helper method to generate the suffixes for code chunks for putting code
+ * @param numChunks number of chunks to generate suffixes for
+ * @returns number[] - an array of numbers corresponding to the code chunks being put
+ */
+export declare const generateBinaryTreeChunkSuffixes: (numChunks: number) => number[];
+/**
+ * Helper method for generating the code stems necessary for putting code
+ * @param numChunks the number of code chunks to be put
+ * @param address the address of the account getting the code
+ * @param hashFunction an initialized {@link BinaryTreeCrypto} object
+ * @returns an array of stems for putting code
+ */
+export declare function generateBinaryTreeCodeStems(numChunks: number, address: Address, hashFunction: (input: Uint8Array) => Uint8Array): Uint8Array[];
+//# sourceMappingURL=binaryTree.d.ts.map

package/dist/esm/binaryTree.d.ts.map

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

package/dist/esm/binaryTree.js

@@ -0,0 +1,226 @@
+import { bigIntToBytes, bytesToBigInt, bytesToInt32, concatBytes, int32ToBytes, intToBytes, setLengthLeft, setLengthRight, } from "./bytes.js";
+/**
+ * @dev Returns the 31-bytes binary tree stem for a given address and tree index.
+ * @param hashFunction The hashFunction for the binary tree
+ * @param {Address} address The address to generate the tree key for.
+ * @param treeIndex The index of the tree to generate the key for. Defaults to 0.
+ * @return The 31-bytes binary tree stem as a Uint8Array.
+ */
+export function getBinaryTreeStem(hashFunction, address, treeIndex = 0) {
+    const address32 = setLengthLeft(address.toBytes(), 32);
+    let treeIndexBytes;
+    if (typeof treeIndex === 'number') {
+        treeIndexBytes = setLengthRight(int32ToBytes(Number(treeIndex), true), 32);
+    }
+    else {
+        treeIndexBytes = setLengthRight(bigIntToBytes(BigInt(treeIndex), true).slice(0, 32), 32);
+    }
+    const treeStem = hashFunction(concatBytes(address32, treeIndexBytes)).slice(0, 31);
+    return treeStem;
+}
+export const BinaryTreeLeafType = {
+    BasicData: 0,
+    CodeHash: 1,
+};
+export const BINARY_TREE_VERSION_OFFSET = 0;
+export const BINARY_TREE_CODE_SIZE_OFFSET = 5;
+export const BINARY_TREE_NONCE_OFFSET = 8;
+export const BINARY_TREE_BALANCE_OFFSET = 16;
+export const BINARY_TREE_VERSION_BYTES_LENGTH = 1;
+export const BINARY_TREE_CODE_SIZE_BYTES_LENGTH = 3;
+export const BINARY_TREE_NONCE_BYTES_LENGTH = 8;
+export const BINARY_TREE_BALANCE_BYTES_LENGTH = 16;
+export const BINARY_TREE_BASIC_DATA_LEAF_KEY = intToBytes(BinaryTreeLeafType.BasicData);
+export const BINARY_TREE_CODE_HASH_LEAF_KEY = intToBytes(BinaryTreeLeafType.CodeHash);
+export const BINARY_TREE_CODE_CHUNK_SIZE = 31;
+export const BINARY_TREE_HEADER_STORAGE_OFFSET = 64;
+export const BINARY_TREE_CODE_OFFSET = 128;
+export const BINARY_TREE_NODE_WIDTH = 256;
+export const BINARY_TREE_MAIN_STORAGE_OFFSET = BigInt(256) ** BigInt(BINARY_TREE_CODE_CHUNK_SIZE);
+/**
+ * @dev Returns the tree key for a given binary tree stem, and sub index.
+ * @dev Assumes that the tree node width = 256
+ * @param stem The 31-bytes binary tree stem as a Uint8Array.
+ * @param subIndex The sub index of the tree to generate the key for as a Uint8Array.
+ * @return The tree key as a Uint8Array.
+ */
+export const getBinaryTreeKey = (stem, leaf) => {
+    switch (leaf) {
+        case BinaryTreeLeafType.BasicData:
+            return concatBytes(stem, BINARY_TREE_BASIC_DATA_LEAF_KEY);
+        case BinaryTreeLeafType.CodeHash:
+            return concatBytes(stem, BINARY_TREE_CODE_HASH_LEAF_KEY);
+        default:
+            return concatBytes(stem, leaf);
+    }
+};
+/**
+ * Calculates the position of the storage key in the BinaryTree tree, determining
+ * both the tree index (the node in the tree) and the subindex (the position within the node).
+ * @param {bigint} storageKey - The key representing a specific storage slot.
+ * @returns {Object} - An object containing the tree index and subindex
+ */
+export function getBinaryTreeIndicesForStorageSlot(storageKey) {
+    let position;
+    if (storageKey < BINARY_TREE_CODE_OFFSET - BINARY_TREE_HEADER_STORAGE_OFFSET) {
+        position = BigInt(BINARY_TREE_HEADER_STORAGE_OFFSET) + storageKey;
+    }
+    else {
+        position = BINARY_TREE_MAIN_STORAGE_OFFSET + storageKey;
+    }
+    const treeIndex = position / BigInt(BINARY_TREE_NODE_WIDTH);
+    const subIndex = Number(position % BigInt(BINARY_TREE_NODE_WIDTH));
+    return { treeIndex, subIndex };
+}
+/**
+ * Calculates the position of the code chunks in the BinaryTree tree, determining
+ * both the tree index (the node in the tree) and the subindex (the position within the node).
+ * @param {bigint} chunkId - The ID representing a specific chunk.
+ * @returns {Object} - An object containing the tree index and subindex
+ */
+export function getBinaryTreeIndicesForCodeChunk(chunkId) {
+    const treeIndex = Math.floor((BINARY_TREE_CODE_OFFSET + chunkId) / BINARY_TREE_NODE_WIDTH);
+    const subIndex = (BINARY_TREE_CODE_OFFSET + chunkId) % BINARY_TREE_NODE_WIDTH;
+    return { treeIndex, subIndex };
+}
+/**
+ * Asynchronously calculates the BinaryTree tree key for the specified code chunk ID.
+ * @param {Address} address - The account address to access code for.
+ * @param {number} chunkId - The ID of the code chunk to retrieve.
+ * @param hashFunction - The hash function used for BinaryTree-related operations.
+ * @returns {Uint8Array} - The BinaryTree tree key as a byte array.
+ */
+export const getBinaryTreeKeyForCodeChunk = (address, chunkId, hashFunction) => {
+    const { treeIndex, subIndex } = getBinaryTreeIndicesForCodeChunk(chunkId);
+    return concatBytes(getBinaryTreeStem(hashFunction, address, treeIndex), intToBytes(subIndex));
+};
+// This code was written by robots based on the reference implementation in EIP-7864
+export const chunkifyBinaryTreeCode = (code) => {
+    const PUSH1 = 0x60; // Assuming PUSH1 is defined as 0x60
+    const PUSH32 = 0x7f; // Assuming PUSH32 is defined as 0x7f
+    const PUSH_OFFSET = 0x5f; // Assuming PUSH_OFFSET is defined as 0x5f
+    // Calculate padding length
+    const paddingLength = (31 - (code.length % 31)) % 31;
+    const paddedCode = new Uint8Array(code.length + paddingLength);
+    paddedCode.set(code);
+    // Pre-allocate the bytesToExecData array
+    const bytesToExecData = new Uint8Array(paddedCode.length + 32);
+    let pos = 0;
+    while (pos < paddedCode.length) {
+        let pushdataBytes = 0;
+        if (PUSH1 <= paddedCode[pos] && paddedCode[pos] <= PUSH32) {
+            pushdataBytes = paddedCode[pos] - PUSH_OFFSET;
+        }
+        pos += 1;
+        for (let x = 0; x < pushdataBytes; x++) {
+            bytesToExecData[pos + x] = pushdataBytes - x;
+        }
+        pos += pushdataBytes;
+    }
+    // Pre-allocate the chunks array
+    const numChunks = Math.ceil(paddedCode.length / 31);
+    const chunks = new Array(numChunks);
+    for (let i = 0, pos = 0; i < numChunks; i++, pos += 31) {
+        const chunk = new Uint8Array(32);
+        chunk[0] = Math.min(bytesToExecData[pos], 31);
+        chunk.set(paddedCode.subarray(pos, pos + 31), 1);
+        chunks[i] = chunk;
+    }
+    return chunks;
+};
+/**
+ * Asynchronously calculates the BinaryTree tree key for the specified storage slot.
+ * @param {Address} address - The account address to access code for.
+ * @param {bigint} storageKey - The storage slot key to retrieve the key for.
+ * @param hashFunction - The hash function used in the Binary Tree.
+ * @returns {Uint8Array} - The BinaryTree tree key as a byte array.
+ */
+export const getBinaryTreeKeyForStorageSlot = (address, storageKey, hashFunction) => {
+    const { treeIndex, subIndex } = getBinaryTreeIndicesForStorageSlot(storageKey);
+    return concatBytes(getBinaryTreeStem(hashFunction, address, treeIndex), intToBytes(subIndex));
+};
+/**
+ * This function extracts and decodes account header elements (version, nonce, code size, and balance)
+ * from an encoded `Uint8Array` representation of raw BinaryTree leaf-node basic data. Each component is sliced
+ * from the `encodedBasicData` array based on predefined offsets and lengths, and then converted
+ * to its appropriate type (integer or BigInt).
+ * @param {Uint8Array} encodedBasicData - The encoded BinaryTree leaf basic data containing the version, nonce,
+ * code size, and balance in a compact Uint8Array format.
+ * @returns {BinaryTreeLeafBasicData} - An object containing the decoded version, nonce, code size, and balance.
+ */
+export function decodeBinaryTreeLeafBasicData(encodedBasicData) {
+    const versionBytes = encodedBasicData.slice(0, BINARY_TREE_VERSION_BYTES_LENGTH);
+    const nonceBytes = encodedBasicData.slice(BINARY_TREE_NONCE_OFFSET, BINARY_TREE_NONCE_OFFSET + BINARY_TREE_NONCE_BYTES_LENGTH);
+    const codeSizeBytes = encodedBasicData.slice(BINARY_TREE_CODE_SIZE_OFFSET, BINARY_TREE_CODE_SIZE_OFFSET + BINARY_TREE_CODE_SIZE_BYTES_LENGTH);
+    const balanceBytes = encodedBasicData.slice(BINARY_TREE_BALANCE_OFFSET, BINARY_TREE_BALANCE_OFFSET + BINARY_TREE_BALANCE_BYTES_LENGTH);
+    const version = bytesToInt32(versionBytes);
+    const nonce = bytesToBigInt(nonceBytes);
+    const codeSize = bytesToInt32(codeSizeBytes);
+    const balance = bytesToBigInt(balanceBytes);
+    return { version, nonce, codeSize, balance };
+}
+/**
+ * This function takes a `BinaryTreeLeafBasicData` object and encodes its properties
+ * (version, nonce, code size, and balance) into a compact `Uint8Array` format. Each
+ * property is serialized and padded to match the required byte lengths defined by
+ * EIP-7864. Additionally, 4 bytes are reserved for future use as specified
+ * in EIP-7864.
+ * @param {Account} account - An object containing the version, nonce,
+ *   code size, and balance to be encoded.
+ * @returns {Uint8Array} - A compact bytes representation of the account header basic data.
+ */
+export function encodeBinaryTreeLeafBasicData(account) {
+    const encodedVersion = setLengthLeft(intToBytes(account.version), BINARY_TREE_VERSION_BYTES_LENGTH);
+    // Per EIP-7864, bytes 1-4 are reserved for future use
+    const reservedBytes = new Uint8Array([0, 0, 0, 0]);
+    const encodedNonce = setLengthLeft(bigIntToBytes(account.nonce), BINARY_TREE_NONCE_BYTES_LENGTH);
+    const encodedCodeSize = setLengthLeft(intToBytes(account.codeSize), BINARY_TREE_CODE_SIZE_BYTES_LENGTH);
+    const encodedBalance = setLengthLeft(bigIntToBytes(account.balance), BINARY_TREE_BALANCE_BYTES_LENGTH);
+    return concatBytes(encodedVersion, reservedBytes, encodedCodeSize, encodedNonce, encodedBalance);
+}
+/**
+ * Helper method to generate the suffixes for code chunks for putting code
+ * @param numChunks number of chunks to generate suffixes for
+ * @returns number[] - an array of numbers corresponding to the code chunks being put
+ */
+export const generateBinaryTreeChunkSuffixes = (numChunks) => {
+    if (numChunks === 0)
+        return [];
+    const chunkSuffixes = new Array(numChunks);
+    let currentSuffix = BINARY_TREE_CODE_OFFSET;
+    for (let x = 0; x < numChunks; x++) {
+        chunkSuffixes[x] = currentSuffix;
+        currentSuffix++;
+        // Reset suffix to 0 if exceeds BINARY_TREE_NODE_WIDTH
+        if (currentSuffix >= BINARY_TREE_NODE_WIDTH)
+            currentSuffix = 0;
+    }
+    return chunkSuffixes;
+};
+/**
+ * Helper method for generating the code stems necessary for putting code
+ * @param numChunks the number of code chunks to be put
+ * @param address the address of the account getting the code
+ * @param hashFunction an initialized {@link BinaryTreeCrypto} object
+ * @returns an array of stems for putting code
+ */
+export function generateBinaryTreeCodeStems(numChunks, address, hashFunction) {
+    // The maximum number of chunks is 793 (maxCodeSize - 24576) / (bytes per chunk 31) + (round up - 1)
+    // Code is stored in chunks starting at leaf index 128 of the leaf node corresponding to the stem of the code's address
+    // Code chunks beyond the initial 128 are stored in additional leaf nodes in batches up of up to 256 chunks per leaf node
+    // so the maximum number of leaf nodes that can hold contract code for a specific address is 4 leaf nodes (128 chunks in
+    // the first leaf node and 256 chunks in up to 3 additional leaf nodes)
+    // So, instead of computing every single leaf key (which is a heavy operation), we just compute the stem for the first
+    // chunk in each leaf node and can then know that the chunks in between have tree keys in monotonically increasing order
+    const numStems = numChunks > BINARY_TREE_CODE_OFFSET ? Math.ceil(numChunks / BINARY_TREE_NODE_WIDTH) + 1 : 1;
+    const chunkStems = new Array(numStems);
+    // Compute the stem for the initial set of code chunks
+    chunkStems[0] = getBinaryTreeKeyForCodeChunk(address, 0, hashFunction).slice(0, 31);
+    for (let stemNum = 0; stemNum < numStems - 1; stemNum++) {
+        // Generate additional stems
+        const firstChunkKey = getBinaryTreeKeyForCodeChunk(address, BINARY_TREE_CODE_OFFSET + stemNum * BINARY_TREE_NODE_WIDTH, hashFunction);
+        chunkStems[stemNum + 1] = firstChunkKey.slice(0, 31);
+    }
+    return chunkStems;
+}
+//# sourceMappingURL=binaryTree.js.map

package/dist/esm/binaryTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binaryTree.js","sourceRoot":"","sources":["../../src/binaryTree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,aAAa,EACb,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,UAAU,EACV,aAAa,EACb,cAAc,GACf,MAAM,YAAY,CAAA;AAMnB;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAC/B,YAA+C,EAC/C,OAAgB,EAChB,YAA6B,CAAC;IAE9B,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,EAAE,CAAC,CAAA;IAEtD,IAAI,cAA0B,CAAA;IAC9B,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,cAAc,GAAG,cAAc,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;IAC5E,CAAC;SAAM,CAAC;QACN,cAAc,GAAG,cAAc,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;IAC1F,CAAC;IAED,MAAM,QAAQ,GAAG,YAAY,CAAC,WAAW,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAElF,OAAO,QAAQ,CAAA;AACjB,CAAC;AAsCD,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,SAAS,EAAE,CAAC;IACZ,QAAQ,EAAE,CAAC;CACH,CAAA;AASV,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAA;AAC3C,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAA;AAC7C,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAA;AACzC,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAA;AAE5C,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAA;AACjD,MAAM,CAAC,MAAM,kCAAkC,GAAG,CAAC,CAAA;AACnD,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAA;AAC/C,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,CAAA;AAElD,MAAM,CAAC,MAAM,+BAA+B,GAAG,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;AACvF,MAAM,CAAC,MAAM,8BAA8B,GAAG,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAA;AAErF,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,CAAA;AAC7C,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,CAAA;AACnD,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAA;AAC1C,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;AACzC,MAAM,CAAC,MAAM,+BAA+B,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,2BAA2B,CAAC,CAAA;AAEjG;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAgB,EAAE,IAAqC,EAAE,EAAE;IAC1F,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,kBAAkB,CAAC,SAAS;YAC/B,OAAO,WAAW,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;QAC3D,KAAK,kBAAkB,CAAC,QAAQ;YAC9B,OAAO,WAAW,CAAC,IAAI,EAAE,8BAA8B,CAAC,CAAA;QAC1D;YACE,OAAO,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IAClC,CAAC;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CAAC,UAAkB;IAInE,IAAI,QAAgB,CAAA;IACpB,IAAI,UAAU,GAAG,uBAAuB,GAAG,iCAAiC,EAAE,CAAC;QAC7E,QAAQ,GAAG,MAAM,CAAC,iCAAiC,CAAC,GAAG,UAAU,CAAA;IACnE,CAAC;SAAM,CAAC;QACN,QAAQ,GAAG,+BAA+B,GAAG,UAAU,CAAA;IACzD,CAAC;IAED,MAAM,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAA;IAC3D,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAA;IAElE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA;AAChC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC,CAAC,OAAe;IAC9D,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,uBAAuB,GAAG,OAAO,CAAC,GAAG,sBAAsB,CAAC,CAAA;IAC1F,MAAM,QAAQ,GAAG,CAAC,uBAAuB,GAAG,OAAO,CAAC,GAAG,sBAAsB,CAAA;IAC7E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA;AAChC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,OAAgB,EAChB,OAAe,EACf,YAA+C,EAC/C,EAAE;IACF,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,gCAAgC,CAAC,OAAO,CAAC,CAAA;IACzE,OAAO,WAAW,CAAC,iBAAiB,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAA;AAC/F,CAAC,CAAA;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,IAAgB,EAAE,EAAE;IACzD,MAAM,KAAK,GAAG,IAAI,CAAA,CAAC,oCAAoC;IACvD,MAAM,MAAM,GAAG,IAAI,CAAA,CAAC,qCAAqC;IACzD,MAAM,WAAW,GAAG,IAAI,CAAA,CAAC,0CAA0C;IAEnE,2BAA2B;IAC3B,MAAM,aAAa,GAAG,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAA;IACpD,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,CAAA;IAC9D,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAEpB,yCAAyC;IACzC,MAAM,eAAe,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;IAE9D,IAAI,GAAG,GAAG,CAAC,CAAA;IACX,OAAO,GAAG,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC;QAC/B,IAAI,aAAa,GAAG,CAAC,CAAA;QACrB,IAAI,KAAK,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,MAAM,EAAE,CAAC;YAC1D,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,WAAW,CAAA;QAC/C,CAAC;QACD,GAAG,IAAI,CAAC,CAAA;QACR,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,eAAe,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,aAAa,GAAG,CAAC,CAAA;QAC9C,CAAC;QACD,GAAG,IAAI,aAAa,CAAA;IACtB,CAAC;IAED,gCAAgC;IAChC,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;IACnD,MAAM,MAAM,GAAG,IAAI,KAAK,CAAa,SAAS,CAAC,CAAA;IAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAA;QAChC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAA;QAC7C,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;QAChD,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;IACnB,CAAC;IAED,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAC5C,OAAgB,EAChB,UAAkB,EAClB,YAA+C,EAC/C,EAAE;IACF,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,kCAAkC,CAAC,UAAU,CAAC,CAAA;IAE9E,OAAO,WAAW,CAAC,iBAAiB,CAAC,YAAY,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAA;AAC/F,CAAC,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,6BAA6B,CAC3C,gBAA4B;IAE5B,MAAM,YAAY,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC,EAAE,gCAAgC,CAAC,CAAA;IAChF,MAAM,UAAU,GAAG,gBAAgB,CAAC,KAAK,CACvC,wBAAwB,EACxB,wBAAwB,GAAG,8BAA8B,CAC1D,CAAA;IACD,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,CAC1C,4BAA4B,EAC5B,4BAA4B,GAAG,kCAAkC,CAClE,CAAA;IACD,MAAM,YAAY,GAAG,gBAAgB,CAAC,KAAK,CACzC,0BAA0B,EAC1B,0BAA0B,GAAG,gCAAgC,CAC9D,CAAA;IAED,MAAM,OAAO,GAAG,YAAY,CAAC,YAAY,CAAC,CAAA;IAC1C,MAAM,KAAK,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;IACvC,MAAM,QAAQ,GAAG,YAAY,CAAC,aAAa,CAAC,CAAA;IAC5C,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,CAAC,CAAA;IAE3C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AAC9C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAAgB;IAC5D,MAAM,cAAc,GAAG,aAAa,CAClC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAC3B,gCAAgC,CACjC,CAAA;IACD,sDAAsD;IACtD,MAAM,aAAa,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAClD,MAAM,YAAY,GAAG,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,8BAA8B,CAAC,CAAA;IAChG,MAAM,eAAe,GAAG,aAAa,CACnC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC5B,kCAAkC,CACnC,CAAA;IACD,MAAM,cAAc,GAAG,aAAa,CAClC,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,EAC9B,gCAAgC,CACjC,CAAA;IACD,OAAO,WAAW,CAAC,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,CAAC,CAAA;AAClG,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,SAAiB,EAAE,EAAE;IACnE,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAC9B,MAAM,aAAa,GAAa,IAAI,KAAK,CAAS,SAAS,CAAC,CAAA;IAC5D,IAAI,aAAa,GAAG,uBAAuB,CAAA;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAA;QAChC,aAAa,EAAE,CAAA;QACf,sDAAsD;QACtD,IAAI,aAAa,IAAI,sBAAsB;YAAE,aAAa,GAAG,CAAC,CAAA;IAChE,CAAC;IAED,OAAO,aAAa,CAAA;AACtB,CAAC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,SAAiB,EACjB,OAAgB,EAChB,YAA+C;IAE/C,oGAAoG;IACpG,uHAAuH;IACvH,yHAAyH;IACzH,wHAAwH;IACxH,uEAAuE;IACvE,sHAAsH;IACtH,wHAAwH;IACxH,MAAM,QAAQ,GACZ,SAAS,GAAG,uBAAuB,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7F,MAAM,UAAU,GAAG,IAAI,KAAK,CAAa,QAAQ,CAAC,CAAA;IAClD,sDAAsD;IACtD,UAAU,CAAC,CAAC,CAAC,GAAG,4BAA4B,CAAC,OAAO,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAEnF,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC;QACxD,4BAA4B;QAC5B,MAAM,aAAa,GAAG,4BAA4B,CAChD,OAAO,EACP,uBAAuB,GAAG,OAAO,GAAG,sBAAsB,EAC1D,YAAY,CACb,CAAA;QACD,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IACtD,CAAC;IACD,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/esm/blobs.d.ts

@@ -0,0 +1,76 @@
+import type { KZG } from './kzg.ts';
+import type { PrefixedHexString } from './types.ts';
+export declare const CELLS_PER_EXT_BLOB = 128;
+/**
+ * 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
+ */
+export declare function getBlob(data: Uint8Array): PrefixedHexString;
+/**
+ * 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
+ */
+export declare const getBlobs: (input: string | string[]) => `0x${string}`[];
+/**
+ * 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)
+ */
+export declare const blobsToCommitments: (kzg: KZG, blobs: PrefixedHexString[]) => `0x${string}`[];
+/**
+ * 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)
+ */
+export declare const blobsToProofs: (kzg: KZG, blobs: PrefixedHexString[], commitments: PrefixedHexString[]) => `0x${string}`[];
+/**
+ * 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
+ */
+export declare const computeVersionedHash: (commitment: PrefixedHexString, blobCommitmentVersion: number) => `0x${string}`;
+/**
+ * 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)
+ */
+export declare const commitmentsToVersionedHashes: (commitments: PrefixedHexString[]) => `0x${string}`[];
+/**
+ * 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
+ */
+export declare const blobsToCells: (kzg: KZG, blobs: PrefixedHexString[]) => [PrefixedHexString[], number[]];
+/**
+ * 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
+ */
+export declare const blobsToCellsAndProofs: (kzg: KZG, blobs: PrefixedHexString[]) => [PrefixedHexString[], PrefixedHexString[], number[]];
+/**
+ * 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)
+ */
+export declare const blobsToCellProofs: (kzg: KZG, blobs: PrefixedHexString[]) => PrefixedHexString[];
+//# sourceMappingURL=blobs.d.ts.map

package/dist/esm/blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobs.d.ts","sourceRoot":"","sources":["../../src/blobs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAYnD,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAerC;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,iBAAiB,CAS3D;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,GAAG,MAAM,EAAE,oBA0BhD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,GAAG,EAAE,OAAO,iBAAiB,EAAE,oBAMtE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,GAAG,EACR,OAAO,iBAAiB,EAAE,EAC1B,aAAa,iBAAiB,EAAE,oBAOjC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,iBAAiB,EAC7B,uBAAuB,MAAM,kBAM9B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GAAI,aAAa,iBAAiB,EAAE,oBAM5E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,GAAG,EACR,OAAO,iBAAiB,EAAE,KACzB,CAAC,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAOhC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAChC,KAAK,GAAG,EACR,OAAO,iBAAiB,EAAE,KACzB,CAAC,iBAAiB,EAAE,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAiBrD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,GAAG,EAAE,OAAO,iBAAiB,EAAE,KAAG,iBAAiB,EAEzF,CAAA"}

package/dist/esm/blobs.js

@@ -0,0 +1,163 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, hexToBytes, utf8ToBytes } from "./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;
+export const 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
+ */
+export 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 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
+ */
+export const getBlobs = (input) => {
+    const inputArray = Array.isArray(input) ? input : [input];
+    const blobs = [];
+    for (const input of inputArray) {
+        const data = 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;
+};
+/**
+ * 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)
+ */
+export const blobsToCommitments = (kzg, blobs) => {
+    const commitments = [];
+    for (const blob of blobs) {
+        commitments.push(kzg.blobToKzgCommitment(blob).toLowerCase());
+    }
+    return commitments;
+};
+/**
+ * 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)
+ */
+export const blobsToProofs = (kzg, blobs, commitments) => {
+    const proofs = blobs.map((blob, ctx) => kzg.computeBlobProof(blob, commitments[ctx]).toLowerCase());
+    return proofs;
+};
+/**
+ * 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
+ */
+export const computeVersionedHash = (commitment, blobCommitmentVersion) => {
+    const computedVersionedHash = new Uint8Array(32);
+    computedVersionedHash.set([blobCommitmentVersion], 0);
+    computedVersionedHash.set(sha256(hexToBytes(commitment)).subarray(1), 1);
+    return bytesToHex(computedVersionedHash);
+};
+/**
+ * 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)
+ */
+export const commitmentsToVersionedHashes = (commitments) => {
+    const hashes = [];
+    for (const commitment of commitments) {
+        hashes.push(computeVersionedHash(commitment, 0x01));
+    }
+    return hashes;
+};
+/**
+ * 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
+ */
+export const blobsToCells = (kzg, blobs) => {
+    const cells = blobs.reduce((acc, elem) => {
+        return [...acc, ...kzg.computeCells(elem)];
+    }, []);
+    const indices = Array.from({ length: CELLS_PER_EXT_BLOB }, (_, i) => i);
+    return [cells, indices];
+};
+/**
+ * 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
+ */
+export 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: CELLS_PER_EXT_BLOB }, (_, i) => i);
+    return [...blobsAndCells, indices];
+};
+/**
+ * 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)
+ */
+export const blobsToCellProofs = (kzg, blobs) => {
+    return blobsToCellsAndProofs(kzg, blobs)[1];
+};
+//# sourceMappingURL=blobs.js.map

package/dist/esm/blobs.js.map

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