@feelyourprotocol/util 8141.0.0

package/src/binaryTree.ts

@@ -0,0 +1,353 @@
+import {
+  bigIntToBytes,
+  bytesToBigInt,
+  bytesToInt32,
+  concatBytes,
+  int32ToBytes,
+  intToBytes,
+  setLengthLeft,
+  setLengthRight,
+} from './bytes.ts'
+
+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 function getBinaryTreeStem(
+  hashFunction: (value: Uint8Array) => Uint8Array,
+  address: Address,
+  treeIndex: number | bigint = 0,
+): Uint8Array {
+  const address32 = setLengthLeft(address.toBytes(), 32)
+
+  let treeIndexBytes: Uint8Array
+  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 interface BinaryTreeStateDiff {
+  stem: PrefixedHexString
+  suffixDiffs: {
+    currentValue: PrefixedHexString | null
+    newValue: PrefixedHexString | null
+    suffix: number | string
+  }[]
+}
+
+// TODO: This is a placeholder type, the actual type is not yet defined
+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 const BinaryTreeLeafType = {
+  BasicData: 0,
+  CodeHash: 1,
+} as const
+
+export type BinaryTreeLeafBasicData = {
+  version: number
+  nonce: bigint
+  balance: bigint
+  codeSize: number
+}
+
+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: Uint8Array, leaf: BinaryTreeLeafType | Uint8Array) => {
+  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: bigint): {
+  treeIndex: bigint
+  subIndex: number
+} {
+  let position: bigint
+  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: number) {
+  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: Address,
+  chunkId: number,
+  hashFunction: (input: Uint8Array) => Uint8Array,
+) => {
+  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: Uint8Array) => {
+  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<Uint8Array>(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: Address,
+  storageKey: bigint,
+  hashFunction: (input: Uint8Array) => Uint8Array,
+) => {
+  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: Uint8Array,
+): BinaryTreeLeafBasicData {
+  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: Account): Uint8Array {
+  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: number) => {
+  if (numChunks === 0) return []
+  const chunkSuffixes: number[] = new Array<number>(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: number,
+  address: Address,
+  hashFunction: (input: Uint8Array) => Uint8Array,
+): Uint8Array[] {
+  // 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<Uint8Array>(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
+}

package/src/blobs.ts

@@ -0,0 +1,209 @@
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { bytesToHex, hexToBytes, utf8ToBytes } from './bytes.ts'
+
+import type { KZG } from './kzg.ts'
+import type { PrefixedHexString } from './types.ts'
+
+/**
+ * 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: Uint8Array, blobs_len: number): Uint8Array {
+  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: Uint8Array): PrefixedHexString {
+  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: string | string[]) => {
+  const inputArray = Array.isArray(input) ? input : [input]
+  const blobs: PrefixedHexString[] = []
+
+  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: KZG, blobs: PrefixedHexString[]) => {
+  const commitments: PrefixedHexString[] = []
+  for (const blob of blobs) {
+    commitments.push(kzg.blobToKzgCommitment(blob).toLowerCase() as PrefixedHexString)
+  }
+  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: KZG,
+  blobs: PrefixedHexString[],
+  commitments: PrefixedHexString[],
+) => {
+  const proofs = blobs.map((blob, ctx) =>
+    kzg.computeBlobProof(blob, commitments[ctx]).toLowerCase(),
+  ) as PrefixedHexString[]
+
+  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: PrefixedHexString,
+  blobCommitmentVersion: number,
+) => {
+  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: PrefixedHexString[]) => {
+  const hashes: PrefixedHexString[] = []
+  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: KZG,
+  blobs: PrefixedHexString[],
+): [PrefixedHexString[], number[]] => {
+  const cells = blobs.reduce((acc, elem) => {
+    return [...acc, ...(kzg.computeCells(elem) as PrefixedHexString[])]
+  }, [] as PrefixedHexString[])
+  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: KZG,
+  blobs: PrefixedHexString[],
+): [PrefixedHexString[], PrefixedHexString[], number[]] => {
+  const blobsAndCells = blobs.reduce(
+    ([cellsAcc, proofsAcc], elem) => {
+      const blobCellsAndProofs = kzg.computeCellsAndProofs(elem) as [
+        PrefixedHexString[],
+        PrefixedHexString[],
+      ]
+      return [
+        [...cellsAcc, ...blobCellsAndProofs[0]],
+        [...proofsAcc, ...blobCellsAndProofs[1]],
+      ]
+    },
+    [[] as PrefixedHexString[], [] as PrefixedHexString[]],
+  )
+
+  const indices = Array.from({ length: CELLS_PER_EXT_BLOB }, (_, i) => i)
+  return [...blobsAndCells, indices] as [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 const blobsToCellProofs = (kzg: KZG, blobs: PrefixedHexString[]): PrefixedHexString[] => {
+  return blobsToCellsAndProofs(kzg, blobs)[1] as PrefixedHexString[]
+}