tx: add peerdas blob transactions support

config/cspell-ts.json

@@ -640,6 +640,7 @@
     "blobschedule",
     "hoodi",
     "peerdas",
-    "getpayload"
+    "getpayload",
+    "ckzg"
   ]
 }

packages/client/bin/utils.ts

@@ -28,7 +28,7 @@ import {
   randomBytes,
   setLengthLeft,
 } from '@ethereumjs/util'
-import { trustedSetup } from '@paulmillr/trusted-setups/fast.js'
+// import { trustedSetup } from '@paulmillr/trusted-setups/fast.js'
 import {
   keccak256 as keccak256WASM,
   secp256k1Expand,
@@ -40,7 +40,7 @@ import {
 import { keccak256 } from 'ethereum-cryptography/keccak.js'
 import { secp256k1 } from 'ethereum-cryptography/secp256k1.js'
 import { sha256 } from 'ethereum-cryptography/sha256.js'
-import { KZG as microEthKZG } from 'micro-eth-signer/kzg'
+// import { KZG as microEthKZG } from 'micro-eth-signer/kzg'
 import * as verkle from 'micro-eth-signer/verkle'
 import * as promClient from 'prom-client'
 import * as yargs from 'yargs'
@@ -54,6 +54,7 @@ import { setupMetrics } from '../src/util/metrics.ts'
 
 import type { CustomCrypto, GenesisState, GethGenesis } from '@ethereumjs/common'
 import type { Address, PrefixedHexString } from '@ethereumjs/util'
+import { default as ckzg } from 'c-kzg'
 import type { Logger } from '../src/logging.ts'
 import type { ClientOpts } from '../src/types.ts'
 
@@ -630,7 +631,66 @@ function generateAccount(): Account {
 export async function getCryptoFunctions(useJsCrypto: boolean): Promise<CustomCrypto> {
   const cryptoFunctions: CustomCrypto = {}
 
-  const kzg = new microEthKZG(trustedSetup)
+  // const kzg = new microEthKZG(trustedSetup)
+  ckzg.loadTrustedSetup(0)
+  const cKzg = {
+    blobToKzgCommitment: (blob: string) => {
+      const blobBytes = hexToBytes(blob as PrefixedHexString)
+      const commitmentBytes = ckzg.blobToKzgCommitment(blobBytes)
+      return bytesToHex(commitmentBytes) as string
+    },
+    computeBlobProof: (blob: string, commitment: string) => {
+      const blobBytes = hexToBytes(blob as PrefixedHexString)
+      const commitmentBytes = hexToBytes(commitment as PrefixedHexString)
+      const proofBytes = ckzg.computeBlobKzgProof(blobBytes, commitmentBytes)
+      return bytesToHex(proofBytes) as string
+    },
+    verifyProof: (commitment: string, z: string, y: string, proof: string) => {
+      const commitmentBytes = hexToBytes(commitment as PrefixedHexString)
+      const zBytes = hexToBytes(z as PrefixedHexString)
+      const yBytes = hexToBytes(y as PrefixedHexString)
+      const proofBytes = hexToBytes(proof as PrefixedHexString)
+      return ckzg.verifyKzgProof(commitmentBytes, zBytes, yBytes, proofBytes)
+    },
+    verifyBlobProofBatch: (blobs: string[], commitments: string[], proofs: string[]) => {
+      const blobsBytes = blobs.map((blb) => hexToBytes(blb as PrefixedHexString))
+      const commitmentsBytes = commitments.map((cmt) => hexToBytes(cmt as PrefixedHexString))
+      const proofsBytes = proofs.map((prf) => hexToBytes(prf as PrefixedHexString))
+      return ckzg.verifyBlobKzgProofBatch(blobsBytes, commitmentsBytes, proofsBytes)
+    },
+    computeCells: (blob: string) => {
+      const blobBytes = hexToBytes(blob as PrefixedHexString)
+      const cellsBytes = ckzg.computeCells(blobBytes)
+      return cellsBytes.map((cellBytes) => bytesToHex(cellBytes)) as string[]
+    },
+    computeCellsAndProofs: (blob: string) => {
+      const blobBytes = hexToBytes(blob as PrefixedHexString)
+      const [cellsBytes, proofsBytes] = ckzg.computeCellsAndKzgProofs(blobBytes)
+      return [
+        cellsBytes.map((cellBytes) => bytesToHex(cellBytes)),
+        proofsBytes.map((prfBytes) => bytesToHex(prfBytes)),
+      ] as [string[], string[]]
+    },
+    recoverCellsAndProofs: (indices: number[], cells: string[]) => {
+      const cellsBytes = cells.map((cell) => hexToBytes(cell as PrefixedHexString))
+      const [allCellsBytes, allProofsBytes] = ckzg.recoverCellsAndKzgProofs(indices, cellsBytes)
+      return [
+        allCellsBytes.map((cellBytes) => bytesToHex(cellBytes)),
+        allProofsBytes.map((prfBytes) => bytesToHex(prfBytes)),
+      ] as [string[], string[]]
+    },
+    verifyCellKzgProofBatch: (
+      commitments: string[],
+      indices: number[],
+      cells: string[],
+      proofs: string[],
+    ) => {
+      const commitmentsBytes = commitments.map((commit) => hexToBytes(commit as PrefixedHexString))
+      const cellsBytes = cells.map((cell) => hexToBytes(cell as PrefixedHexString))
+      const proofsBytes = proofs.map((prf) => hexToBytes(prf as PrefixedHexString))
+      return ckzg.verifyCellKzgProofBatch(commitmentsBytes, indices, cellsBytes, proofsBytes)
+    },
+  }
   // Initialize WASM crypto if JS crypto is not specified
   if (useJsCrypto === false) {
     await waitReadyPolkadotSha256()
@@ -674,7 +734,7 @@ export async function getCryptoFunctions(useJsCrypto: boolean): Promise<CustomCr
       return address
     }
   }
-  cryptoFunctions.kzg = kzg
+  cryptoFunctions.kzg = cKzg
   cryptoFunctions.verkle = verkle
   return cryptoFunctions
 }

packages/client/package.json

@@ -72,6 +72,7 @@
     "@scure/base": "^1.2.4",
     "abstract-level": "^3.0.1",
     "body-parser": "^1.20.3",
+    "c-kzg": "^4.1.0",
     "chalk": "^5.4.1",
     "connect": "^3.7.0",
     "cors": "^2.8.5",

packages/client/src/rpc/modules/engine/engine.ts

@@ -25,6 +25,7 @@ import { middleware, validators } from '../../validation.ts'
 import { CLConnectionManager, middleware as cmMiddleware } from './CLConnectionManager.ts'
 import {
   type BlobAndProofV1,
+  type BlobAndProofV2,
   type Bytes8,
   type Bytes32,
   type ChainCache,
@@ -290,6 +291,13 @@ export class Engine {
       () => this.connectionManager.updateStatus(),
     )
 
+    this.getPayloadV5 = cmMiddleware(
+      middleware(callWithStackTrace(this.getPayloadV5.bind(this), this._rpcDebug), 1, [
+        [validators.bytes8],
+      ]),
+      () => this.connectionManager.updateStatus(),
+    )
+
     /**
      * exchangeCapabilities
      */
@@ -325,6 +333,12 @@ export class Engine {
       ]),
       () => this.connectionManager.updateStatus(),
     )
+    this.getBlobsV2 = cmMiddleware(
+      middleware(callWithStackTrace(this.getBlobsV2.bind(this), this._rpcDebug), 1, [
+        [validators.array(validators.bytes32)],
+      ]),
+      () => this.connectionManager.updateStatus(),
+    )
   }
 
   /**
@@ -1330,6 +1344,11 @@ export class Engine {
       let checkNotAfterHf: Hardfork | null
 
       switch (payloadVersion) {
+        case 5:
+          checkNotBeforeHf = Hardfork.Osaka
+          checkNotAfterHf = Hardfork.Osaka
+          break
+
         case 4:
           checkNotBeforeHf = Hardfork.Prague
           checkNotAfterHf = Hardfork.Prague
@@ -1408,6 +1427,10 @@ export class Engine {
     return this.getPayload(params, 4)
   }
 
+  async getPayloadV5(params: [Bytes8]) {
+    return this.getPayload(params, 5)
+  }
+
   /**
    * Returns a list of engine API endpoints supported by the client
    *
@@ -1506,11 +1529,31 @@ export class Engine {
       }
     }
 
-    const blobsAndProof: (BlobAndProofV1 | null)[] = []
+    const blobAndProofArr: (BlobAndProofV1 | null)[] = []
     for (const versionedHashHex of params[0]) {
-      blobsAndProof.push(this.service.txPool.blobsAndProofsByHash.get(versionedHashHex) ?? null)
+      blobAndProofArr.push(this.service.txPool.blobAndProofByHash.get(versionedHashHex) ?? null)
+    }
+
+    return blobAndProofArr
+  }
+
+  private async getBlobsV2(params: [[Bytes32]]): Promise<BlobAndProofV2[] | null> {
+    if (params[0].length > 128) {
+      throw {
+        code: TOO_LARGE_REQUEST,
+        message: `More than 128 hashes queried`,
+      }
+    }
+
+    const blobAndProofsArr: BlobAndProofV2[] = []
+    for (const versionedHashHex of params[0]) {
+      const blobAndProofs = this.service.txPool.blobAndProofsByHash.get(versionedHashHex)
+      if (blobAndProofs === undefined) {
+        return null
+      }
+      blobAndProofsArr.push(blobAndProofs)
     }
 
-    return blobsAndProof
+    return blobAndProofsArr
   }
 }

packages/client/src/rpc/modules/engine/types.ts

@@ -61,7 +61,10 @@ export type ForkchoiceResponseV1 = {
   payloadId: Bytes8 | null
 }
 
-export type BlobsBundleV1 = {
+/**
+ * BlobsBundle V1 & V2 are just the same object type only different is proofs are cell proofs in V2
+ */
+export type BlobsBundleV1OrV2 = {
   commitments: Bytes48[]
   blobs: Blob[]
   proofs: Bytes48[]
@@ -77,6 +80,11 @@ export type BlobAndProofV1 = {
   proof: PrefixedHexString
 }
 
+export type BlobAndProofV2 = {
+  blob: PrefixedHexString
+  proofs: PrefixedHexString[]
+}
+
 export type ChainCache = {
   remoteBlocks: Map<string, Block>
   executedBlocks: Map<string, Block>

packages/client/src/rpc/modules/engine/util/getPayload.ts

@@ -3,7 +3,7 @@ import { bigIntToHex, bytesToHex } from '@ethereumjs/util'
 import type { Block, ExecutionPayload } from '@ethereumjs/block'
 import type { CLRequest, CLRequestType } from '@ethereumjs/util'
 import type { BlobsBundle } from '../../../../miner/index.ts'
-import type { BlobsBundleV1 } from '../types.ts'
+import type { BlobsBundleV1OrV2 } from '../types.ts'
 
 /**
  * Formats a block to {@link ExecutionPayloadV1}.
@@ -20,7 +20,7 @@ export const blockToExecutionPayload = (
     delete executionPayload.parentBeaconBlockRoot
   }
 
-  const blobsBundle: BlobsBundleV1 | undefined = bundle ?? undefined
+  const blobsBundle: BlobsBundleV1OrV2 | undefined = bundle ?? undefined
 
   // ethereumjs does not provide any transaction censoring detection (yet) to suggest
   // overriding builder/mev-boost blocks

packages/client/src/rpc/modules/eth.ts

@@ -8,6 +8,7 @@ import {
 } from '@ethereumjs/statemanager'
 import {
   Capability,
+  NetworkWrapperType,
   createBlob4844TxFromSerializedNetworkWrapper,
   createTx,
   createTxFromRLP,
@@ -1160,6 +1161,14 @@ export class Eth {
       if (txBuf[0] === 0x03) {
         // Blob Transactions sent over RPC are expected to be in Network Wrapper format
         tx = createBlob4844TxFromSerializedNetworkWrapper(txBuf, { common })
+        if (
+          common.isActivatedEIP(7594) &&
+          tx.networkWrapperVersion !== NetworkWrapperType.EIP7594
+        ) {
+          throw Error(
+            `tx with networkWrapperVersion=${tx.networkWrapperVersion} sent for EIP-7594 activated hardfork=${common.hardfork()}`,
+          )
+        }
 
         const blobGasLimit = tx.common.param('maxBlobGasPerBlock')
         const blobGasPerBlob = tx.common.param('blobGasPerBlob')