EIP-4844: switch tx.rlpHash usage to tx.binaryHash

nimbus/core/executor/process_transaction.nim

@@ -45,9 +45,6 @@ proc processTransactionImpl(
  ## Modelled after `https://eips.ethereum.org/EIPS/eip-1559#specification`_
  ## which provides a backward compatible framwork for EIP1559.
 
- #trace "Sender", sender
- #trace "txHash", rlpHash = ty.rlpHash
-
  let
  roDB = vmState.readOnlyStateDB
  baseFee256 = header.eip1559BaseFee(fork)

nimbus/core/tx_pool/tx_item.nim

@@ -147,7 +147,7 @@ proc hash*(item: TxItemRef): Hash =
 
 proc itemID*(tx: Transaction): Hash256 =
  ## Getter, transaction ID
- tx.rlpHash
+ tx.binaryHash
 
 # core/types/transaction.go(297): func (tx *Transaction) Cost() *big.Int {
 proc cost*(tx: Transaction): UInt256 =

nimbus/db/db_chain.nim

@@ -187,7 +187,7 @@ proc persistTransactions*(db: ChainDBRef, blockNumber:
  for idx, tx in transactions:
  let
  encodedTx = rlp.encode(tx.removeNetworkPayload)
- txHash = rlpHash(tx) # beware EIP-4844
+ txHash = binaryHash(tx) # beware EIP-4844
  txKey: TransactionKey = (blockNumber, idx)
  trie.put(rlp.encode(idx), encodedTx)
  db.db.put(transactionHashToBlockKey(txHash).toOpenArray, rlp.encode(txKey))
@@ -220,7 +220,7 @@ iterator getBlockTransactionHashes*(db: ChainDBRef, blockHeader: BlockHeader): H
  ## by the given block header.
  for encodedTx in db.getBlockTransactionData(blockHeader.txRoot):
  let tx = rlp.decode(encodedTx, Transaction)
- yield rlpHash(tx) # beware EIP-4844
+ yield binaryHash(tx) # beware EIP-4844
 
 proc getTransactionCount*(chain: ChainDBRef, txRoot: Hash256): int =
  var trie = initHexaryTrie(chain.db, txRoot)

nimbus/graphql/ethapi.nim

@@ -557,7 +557,7 @@ const logProcs = {
 proc txHash(ud: RootRef, params: Args, parent: Node): RespResult {.apiPragma.} =
  let
  tx = TxNode(parent)
- txHash = rlpHash(tx.tx)
+ txHash = binaryHash(tx.tx) # beware EIP-4844
  resp(txHash)
 
 proc txNonce(ud: RootRef, params: Args, parent: Node): RespResult {.apiPragma.} =
@@ -1224,7 +1224,7 @@ proc sendRawTransaction(ud: RootRef, params: Args, parent: Node): RespResult {.a
  try:
  let data = hexToSeqByte(params[0].val.stringVal)
  let tx = decodeTx(data) # we want to know if it is a valid tx blob
- let txHash = rlpHash(tx) # beware EIP-4844
+ let txHash = binaryHash(tx) # beware EIP-4844
  resp(txHash)
  except Exception as em:
  return err("failed to process raw transaction")

nimbus/rpc/filters.nim

@@ -42,7 +42,7 @@ proc deriveLogs*(header: BlockHeader, transactions: seq[Transaction], receipts:
  removed: false,
  logIndex: some(encodeQuantity(uint32(logIndex))),
  transactionIndex: some(encodeQuantity(uint32(i))),
- transactionHash: some(transactions[i].rlpHash),
+ transactionHash: some(transactions[i].binaryHash),
  blockHash: some(header.blockHash),
  blockNumber: some(encodeQuantity(header.blockNumber)),
  address: log.address,

nimbus/rpc/p2p.nim

@@ -257,7 +257,7 @@ proc setupEthRpc*(
  signedTx = signTransaction(tx, acc.privateKey, com.chainId, eip155)
 
  txPool.add(signedTx)
- result = rlpHash(signedTx).ethHashStr
+ result = binaryHash(signedTx).ethHashStr
 
  server.rpc("eth_sendRawTransaction") do(data: HexDataStr) -> EthHashStr:
  ## Creates new message call transaction or a contract creation for signed transactions.
@@ -270,7 +270,7 @@ proc setupEthRpc*(
  signedTx = decodeTx(txBytes)
 
  txPool.add(signedTx)
- result = rlpHash(signedTx).ethHashStr
+ result = binaryHash(signedTx).ethHashStr
 
  server.rpc("eth_call") do(call: EthCall, quantityTag: string) -> HexDataStr:
  ## Executes a new message call immediately without creating a transaction on the block chain.

nimbus/rpc/rpc_utils.nim

@@ -130,7 +130,7 @@ proc populateTransactionObject*(tx: Transaction, header: BlockHeader, txIndex: i
  result.`from` = tx.getSender()
  result.gas = encodeQuantity(tx.gasLimit.uint64)
  result.gasPrice = encodeQuantity(tx.gasPrice.uint64)
- result.hash = tx.rlpHash
+ result.hash = tx.binaryHash
  result.input = tx.payload
  result.nonce = encodeQuantity(tx.nonce.uint64)
  result.to = some(tx.destination)
@@ -183,7 +183,7 @@ proc populateBlockObject*(header: BlockHeader, chain: ChainDBRef, fullTx: bool,
 
 proc populateReceipt*(receipt: Receipt, gasUsed: GasInt, tx: Transaction,
  txIndex: int, header: BlockHeader, fork: EVMFork): ReceiptObject =
- result.transactionHash = tx.rlpHash
+ result.transactionHash = tx.binaryHash
  result.transactionIndex = encodeQuantity(txIndex.uint)
  result.blockHash = header.hash
  result.blockNumber = encodeQuantity(header.blockNumber)

nimbus/sync/handlers/eth.nim

@@ -274,7 +274,7 @@ proc fetchTransactions(ctx: EthWireRef, reqHashes: seq[Hash256], peer: Peer): Fu
 
  # Remove from pending list regardless if tx is in result
  for tx in txs.transactions:
- let txHash = rlpHash(tx)
+ let txHash = binaryHash(tx)
  ctx.pending.excl txHash
 
  ctx.txPool.add(txs.transactions)
@@ -468,7 +468,7 @@ method handleAnnouncedTxs*(ctx: EthWireRef, peer: Peer, txs: openArray[Transacti
 
  var txHashes = newSeqOfCap[Hash256](txs.len)
  for tx in txs:
- txHashes.add rlpHash(tx)
+ txHashes.add binaryHash(tx)
 
  ctx.addToKnownByPeer(txHashes, peer)
  ctx.txPool.add(txs)

nimbus/sync/protocol/les_protocol.nim

@@ -457,10 +457,7 @@ p2pProtocol les(version = lesVersion,
 
  var results: seq[TransactionStatusMsg]
  for t in transactions:
- let hash = t.rlpHash # TODO: this is not optimal, we can compute
- # the hash from the request bytes.
- # The RLP module can offer a helper Hashed[T]
- # to make this easy.
+ let hash = t.binaryHash
  var s = ctx.getTransactionStatus(hash)
  if s.status == TransactionStatus.Unknown:
  ctx.addTransactions([t])
@@ -479,7 +476,7 @@ p2pProtocol les(version = lesVersion,
 
  var results: seq[TransactionStatusMsg]
  for t in transactions:
- results.add ctx.getTransactionStatus(t.rlpHash)
+ results.add ctx.getTransactionStatus(t.binaryHash)
  await response.send(updateBV(), results)
 
  proc txStatus(