wire in forkedchain to p2p

execution_chain/core/chain/forked_chain.nim

@@ -660,6 +660,16 @@ proc blockByHash*(c: ForkedChainRef, blockHash: Hash32): Result[Block, string] =
     return ok(loc[].blk)
   c.baseTxFrame.getEthBlock(blockHash)
 
+proc blockBodyByHash*(c: ForkedChainRef, blockHash: Hash32): Result[BlockBody, string] =
+  c.hashToBlock.withValue(blockHash, loc):
+    let blk = loc[].blk
+    return ok(BlockBody(
+      transactions: blk.transactions,
+      uncles: blk.uncles,
+      withdrawals: blk.withdrawals,
+    ))
+  c.baseTxFrame.getBlockBody(blockHash)
+
 proc blockByNumber*(c: ForkedChainRef, number: BlockNumber): Result[Block, string] =
   if number > c.activeBranch.headNumber:
     return err("Requested block number not exists: " & $number)
@@ -675,6 +685,20 @@ proc blockByNumber*(c: ForkedChainRef, number: BlockNumber): Result[Block, strin
 
   err("Block not found, number = " & $number)
 
+proc blockHeader*(c: ForkedChainRef, blk: BlockHashOrNumber): Result[Header, string] =
+  if blk.isHash:
+    return c.headerByHash(blk.hash)
+  c.headerByNumber(blk.number)
+
+proc receiptsByBlockHash*(c: ForkedChainRef, blockHash: Hash32): Result[seq[Receipt], string] =
+  c.hashToBlock.withValue(blockHash, loc):
+    return ok(loc[].receipts)
+
+  let header = c.headerByHash(blockHash).valueOr:
+    return err("Block hash not found")
+
+  c.baseTxFrame.getReceipts(header.receiptsRoot)
+
 func blockFromBaseTo*(c: ForkedChainRef, number: BlockNumber): seq[Block] =
   # return block in reverse order
   var branch = c.activeBranch

execution_chain/core/chain/forked_chain/chain_branch.nim

@@ -103,6 +103,9 @@ func header*(loc: BlockPos): Header =
 func blk*(loc: BlockPos): Block =
   loc.branch.blocks[loc.index].blk
 
+func receipts*(loc: BlockPos): seq[Receipt] =
+  loc.branch.blocks[loc.index].receipts
+
 func number*(loc: BlockPos): BlockNumber =
   loc.branch.blocks[loc.index].blk.header.number
 

execution_chain/sync/handlers/eth.nim

@@ -56,38 +56,6 @@ proc notEnabled(name: string) {.used.} =
 proc notImplemented(name: string) {.used.} =
   debug "Wire handler method not implemented", meth = name
 
-proc successorHeader(db: CoreDbRef,
-                     h: Header,
-                     skip = 0'u): Opt[Header] =
-  let offset = 1 + skip.BlockNumber
-  if h.number <= (not 0.BlockNumber) - offset:
-    # TODO why is this using base db?
-    let header = db.baseTxFrame().getBlockHeader(h.number + offset).valueOr:
-      return Opt.none(Header)
-    return Opt.some(header)
-  Opt.none(Header)
-
-proc ancestorHeader(db: CoreDbRef,
-                     h: Header,
-                     skip = 0'u): Opt[Header] =
-  let offset = 1 + skip.BlockNumber
-  if h.number >= offset:
-    # TODO why is this using base db?
-    let header = db.baseTxFrame().getBlockHeader(h.number - offset).valueOr:
-      return Opt.none(Header)
-    return Opt.some(header)
-  Opt.none(Header)
-
-proc blockHeader(db: CoreDbRef,
-                 b: BlockHashOrNumber): Opt[Header] =
-  let header = if b.isHash:
-                 db.baseTxFrame().getBlockHeader(b.hash).valueOr:
-                   return Opt.none(Header)
-               else:
-                 db.baseTxFrame().getBlockHeader(b.number).valueOr:
-                   return Opt.none(Header)
-  Opt.some(header)
-
 # ------------------------------------------------------------------------------
 # Private functions: peers related functions
 # ------------------------------------------------------------------------------
@@ -321,15 +289,9 @@ method getReceipts*(ctx: EthWireRef,
                     hashes: openArray[Hash32]):
                       Result[seq[seq[Receipt]], string]
     {.gcsafe.} =
-  let db = ctx.db
   var list: seq[seq[Receipt]]
   for blockHash in hashes:
-    # TODO forkedChain
-    let header = db.baseTxFrame().getBlockHeader(blockHash).valueOr:
-      list.add @[]
-      trace "handlers.getReceipts: blockHeader not found", blockHash
-      continue
-    let receiptList = ?db.baseTxFrame().getReceipts(header.receiptsRoot)
+    let receiptList = ?ctx.chain.receiptsByBlockHash(blockHash)
     list.add receiptList
 
   return ok(list)
@@ -357,11 +319,9 @@ method getBlockBodies*(ctx: EthWireRef,
                        hashes: openArray[Hash32]):
                         Result[seq[BlockBody], string]
     {.gcsafe.} =
-  let db = ctx.db
   var list: seq[BlockBody]
   for blockHash in hashes:
-    # TODO forkedChain
-    let body = db.baseTxFrame().getBlockBody(blockHash).valueOr:
+    let body = ctx.chain.blockBodyByHash(blockHash).valueOr:
       list.add BlockBody()
       trace "handlers.getBlockBodies: blockBody not found", blockHash
       continue
@@ -373,18 +333,18 @@ method getBlockHeaders*(ctx: EthWireRef,
                         req: EthBlocksRequest):
                           Result[seq[Header], string]
     {.gcsafe.} =
-  let db = ctx.db
+  let chain = ctx.chain
   var list = newSeqOfCap[Header](req.maxResults)
-  var foundBlock = db.blockHeader(req.startBlock).valueOr:
+  var foundBlock = chain.blockHeader(req.startBlock).valueOr:
     return ok(list)
   list.add foundBlock
 
   while uint64(list.len) < req.maxResults:
     if not req.reverse:
-      foundBlock = db.successorHeader(foundBlock, req.skip).valueOr:
+      foundBlock = chain.headerByNumber(foundBlock.number + 1 + req.skip).valueOr:
         break
     else:
-      foundBlock = db.ancestorHeader(foundBlock, req.skip).valueOr:
+      foundBlock = chain.headerByNumber(foundBlock.number - 1 - req.skip).valueOr:
         break
     list.add foundBlock
   return ok(list)