Align PooledTransaction to the spec (#3350)

Author: jangko

execution_chain/beacon/beacon_engine.nim

@@ -8,7 +8,7 @@
 # those terms.
 
 import
-  std/[sequtils, tables],
+  std/[tables],
   eth/common/[hashes, headers],
   chronicles,
   minilru,
@@ -178,7 +178,7 @@ proc generateExecutionBundle*(ben: BeaconEngineRef,
       blobsBundle = Opt.some BlobsBundleV1(
         commitments: blobData.commitments,
         proofs: blobData.proofs,
-        blobs: blobData.blobs.mapIt it.Web3Blob)
+        blobs: blobData.blobs)
 
     ok ExecutionBundle(
       payload: executionPayload(bundle.blk),

execution_chain/beacon/web3_eth_conv.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -27,7 +27,6 @@ type
   Web3Quantity*      = web3types.Quantity
   Web3ExtraData*     = web3types.DynamicBytes[0, 32]
   Web3Tx*            = engine_api_types.TypedTransaction
-  Web3Blob*          = engine_api_types.Blob
 
 {.push gcsafe, raises:[].}
 

execution_chain/core/eip4844.nim

@@ -177,35 +177,35 @@ func validateEip4844Header*(
 
 proc validateBlobTransactionWrapper*(tx: PooledTransaction):
                                      Result[void, string] {.raises: [].} =
-  if tx.networkPayload.isNil:
+  if tx.blobsBundle.isNil:
     return err("tx wrapper is none")
 
   # note: assert blobs are not malformatted
   let goodFormatted = tx.tx.versionedHashes.len ==
-                      tx.networkPayload.commitments.len and
+                      tx.blobsBundle.commitments.len and
                       tx.tx.versionedHashes.len ==
-                      tx.networkPayload.blobs.len and
+                      tx.blobsBundle.blobs.len and
                       tx.tx.versionedHashes.len ==
-                      tx.networkPayload.proofs.len
+                      tx.blobsBundle.proofs.len
 
   if not goodFormatted:
     return err("tx wrapper is ill formatted")
 
-  let commitments = tx.networkPayload.commitments.mapIt(
+  let commitments = tx.blobsBundle.commitments.mapIt(
                       kzg.KzgCommitment(bytes: it.data))
 
   # Verify that commitments match the blobs by checking the KZG proof
   let res = kzg.verifyBlobKzgProofBatch(
-              tx.networkPayload.blobs.mapIt(kzg.KzgBlob(bytes: it)),
+              tx.blobsBundle.blobs.mapIt(kzg.KzgBlob(bytes: it.bytes)),
               commitments,
-              tx.networkPayload.proofs.mapIt(kzg.KzgProof(bytes: it.data)))
+              tx.blobsBundle.proofs.mapIt(kzg.KzgProof(bytes: it.data)))
 
   if res.isErr:
     return err(res.error)
 
   # Actual verification result
   if not res.get():
-    return err("Failed to verify network payload of a transaction")
+    return err("Failed to verify blobs bundle of a transaction")
 
   # Now that all commitments have been verified, check that versionedHashes matches the commitments
   for i in 0 ..< tx.tx.versionedHashes.len:

execution_chain/core/pooled_txs.nim

@@ -10,23 +10,21 @@
 {.push raises: [].}
 
 import
-  eth/common/transactions
+  eth/common/transactions,
+  web3/primitives
 
 export
-  transactions
+  transactions,
+  primitives
 
 type
-  # 32 -> UInt256
-  # 4096 -> FIELD_ELEMENTS_PER_BLOB
-  NetworkBlob* = array[32*4096, byte]
+  KzgBlob* = primitives.Blob
 
-  BlobsBundle* = object
+  BlobsBundle* = ref object
     commitments*: seq[KzgCommitment]
     proofs*: seq[KzgProof]
-    blobs*: seq[NetworkBlob]
-
-  NetworkPayload* = ref BlobsBundle
+    blobs*: seq[KzgBlob]
 
   PooledTransaction* = object
     tx*: Transaction
-    networkPayload*: NetworkPayload       # EIP-4844
+    blobsBundle*: BlobsBundle       # EIP-4844

execution_chain/core/pooled_txs_rlp.nim

@@ -17,39 +17,45 @@ export
   transactions_rlp,
   pooled_txs
 
-proc append(w: var RlpWriter, networkPayload: NetworkPayload) =
-  w.append(networkPayload.blobs)
-  w.append(networkPayload.commitments)
-  w.append(networkPayload.proofs)
+proc append(w: var RlpWriter, blob: Blob) =
+  w.append(blob.bytes)
+
+proc append(w: var RlpWriter, blobsBundle: BlobsBundle) =
+  w.append(blobsBundle.blobs)
+  w.append(blobsBundle.commitments)
+  w.append(blobsBundle.proofs)
 
 proc append*(w: var RlpWriter, tx: PooledTransaction) =
   if tx.tx.txType != TxLegacy:
     w.append(tx.tx.txType)
-  if tx.networkPayload != nil:
+  if tx.blobsBundle != nil:
     w.startList(4) # spec: rlp([tx_payload, blobs, commitments, proofs])
   w.appendTxPayload(tx.tx)
-  if tx.networkPayload != nil:
-    w.append(tx.networkPayload)
+  if tx.blobsBundle != nil:
+    w.append(tx.blobsBundle)
+
+proc read(rlp: var Rlp, T: type Blob): T {.raises: [RlpError].} =
+  rlp.read(result.bytes)
 
-proc read(rlp: var Rlp, T: type NetworkPayload): T {.raises: [RlpError].} =
-  result = NetworkPayload()
+proc read(rlp: var Rlp, T: type BlobsBundle): T {.raises: [RlpError].} =
+  result = BlobsBundle()
   rlp.read(result.blobs)
   rlp.read(result.commitments)
   rlp.read(result.proofs)
 
 proc readTxTyped(rlp: var Rlp, tx: var PooledTransaction) {.raises: [RlpError].} =
   let
     txType = rlp.readTxType()
-    hasNetworkPayload =
+    hasBlobsBundle =
       if txType == TxEip4844:
         rlp.listLen == 4
       else:
         false
-  if hasNetworkPayload:
+  if hasBlobsBundle:
     rlp.tryEnterList() # spec: rlp([tx_payload, blobs, commitments, proofs])
   rlp.readTxPayload(tx.tx, txType)
-  if hasNetworkPayload:
-    rlp.read(tx.networkPayload)
+  if hasBlobsBundle:
+    rlp.read(tx.blobsBundle)
 
 proc read*(rlp: var Rlp, T: type PooledTransaction): T {.raises: [RlpError].} =
   if rlp.isList:

execution_chain/core/tx_pool.nim

@@ -147,16 +147,16 @@ proc assembleBlock*(
   var blk = EthBlock(
     header: pst.assembleHeader(xp)
   )
-  var blobsBundle: BlobsBundle
+  var blobsBundle = BlobsBundle()
   for item in pst.packedTxs:
     let tx = item.pooledTx
     blk.txs.add tx.tx
-    if tx.networkPayload != nil:
-      for k in tx.networkPayload.commitments:
+    if tx.blobsBundle != nil:
+      for k in tx.blobsBundle.commitments:
         blobsBundle.commitments.add k
-      for p in tx.networkPayload.proofs:
+      for p in tx.blobsBundle.proofs:
         blobsBundle.proofs.add p
-      for blob in tx.networkPayload.blobs:
+      for blob in tx.blobsBundle.blobs:
         blobsBundle.blobs.add blob
   blk.header.transactionsRoot = calcTxRoot(blk.txs)
 

execution_chain/core/tx_pool/tx_desc.nim

@@ -414,9 +414,9 @@ iterator byPriceAndNonce*(xp: TxPoolRef): TxItemRef =
 
 func getBlobAndProofV1*(xp: TxPoolRef, v: VersionedHash): Opt[BlobAndProofV1] =
   xp.blobTab.withValue(v, val):
-    let np = val.item.pooledTx.networkPayload
+    let np = val.item.pooledTx.blobsBundle
     return Opt.some(BlobAndProofV1(
-      blob: engine_api_types.Blob(np.blobs[val.blobIndex]),
+      blob: np.blobs[val.blobIndex],
       proof: np.proofs[val.blobIndex]))
 
   Opt.none(BlobAndProofV1)

execution_chain/rpc/rpc_utils.nim

@@ -149,7 +149,8 @@ proc populateBlockObject*(blockHash: Hash32,
   result.mixHash = Hash32 header.mixHash
 
   # discard sizeof(seq[byte]) of extraData and use actual length
-  let size = sizeof(eth_types.Header) - sizeof(eth_api_types.Blob) + header.extraData.len
+  type ExtraDataType = typeof(header.extraData)
+  let size = sizeof(eth_types.Header) - sizeof(ExtraDataType) + header.extraData.len
   result.size = Quantity(size)
 
   result.gasLimit  = Quantity(header.gasLimit)
@@ -181,7 +182,7 @@ proc populateBlockObject*(blockHash: Hash32,
 
 proc populateReceipt*(rec: StoredReceipt, gasUsed: GasInt, tx: Transaction,
                       txIndex: uint64, header: Header, com: CommonRef): ReceiptObject =
-  let 
+  let
     sender = tx.recoverSender()
     receipt = rec.to(Receipt)
   var res = ReceiptObject()

execution_chain/rpc/server_api.nim

@@ -499,7 +499,7 @@ proc setupServerAPI*(api: ServerAPIRef, server: RpcServer, ctx: EthContext) =
       tx = unsignedTx(data, api.chain, accDB.getNonce(address) + 1, api.com.chainId)
       eip155 = api.com.isEIP155(api.chain.latestNumber)
       signedTx = signTransaction(tx, acc.privateKey, eip155)
-      networkPayload =
+      blobsBundle =
         if signedTx.txType == TxEip4844:
           if data.blobs.isNone or data.commitments.isNone or data.proofs.isNone:
             raise newException(ValueError, "EIP-4844 transaction needs blobs")
@@ -509,16 +509,16 @@ proc setupServerAPI*(api: ServerAPIRef, server: RpcServer, ctx: EthContext) =
             raise newException(ValueError, "Incorrect number of commitments")
           if data.proofs.get.len != signedTx.versionedHashes.len:
             raise newException(ValueError, "Incorrect number of proofs")
-          NetworkPayload(
-            blobs: data.blobs.get.mapIt it.NetworkBlob,
+          BlobsBundle(
+            blobs: data.blobs.get,
             commitments: data.commitments.get,
             proofs: data.proofs.get,
           )
         else:
           if data.blobs.isSome or data.commitments.isSome or data.proofs.isSome:
             raise newException(ValueError, "Blobs require EIP-4844 transaction")
           nil
-      pooledTx = PooledTransaction(tx: signedTx, networkPayload: networkPayload)
+      pooledTx = PooledTransaction(tx: signedTx, blobsBundle: blobsBundle)
 
     api.txPool.addTx(pooledTx).isOkOr:
       raise newException(ValueError, $error)

execution_chain/utils/debug.nim

@@ -137,13 +137,13 @@ proc debug*(tx: Transaction): string =
 
 proc debug*(tx: PooledTransaction): string =
   result.add debug(tx.tx)
-  if tx.networkPayload.isNil:
+  if tx.blobsBundle.isNil:
     result.add "networkPaylod : nil\n"
   else:
     result.add "networkPaylod : \n"
-    result.add " - blobs       : " & $tx.networkPayload.blobs.len & "\n"
-    result.add " - commitments : " & $tx.networkPayload.commitments.len & "\n"
-    result.add " - proofs      : " & $tx.networkPayload.proofs.len & "\n"
+    result.add " - blobs       : " & $tx.blobsBundle.blobs.len & "\n"
+    result.add " - commitments : " & $tx.blobsBundle.commitments.len & "\n"
+    result.add " - proofs      : " & $tx.blobsBundle.proofs.len & "\n"
 
 proc debugSum*(h: Header): string =
   result.add "txRoot         : " & $h.txRoot      & "\n"