txs, receipts and logs

Author: chirag-parmar

nimbus_verified_proxy/rpc/receipts.nim

@@ -0,0 +1,125 @@
+import
+  stint,
+  results,
+  eth/common/eth_types_rlp,
+  eth/trie/[ordered_trie, trie_defs],
+  json_rpc/[rpcproxy, rpcserver, rpcclient],
+  web3/[eth_api_types, eth_api],
+  ../../execution_chain/beacon/web3_eth_conv,
+  ../types,
+  ./blocks
+
+template toLog(lg: LogObject): Log =
+  Log(address: lg.address, topics: lg.topics, data: lg.data)
+
+func toLogs(logs: openArray[LogObject]): seq[Log] =
+  result = newSeqOfCap[Log](logs.len)
+  for lg in logs:
+    result.add(toLog(lg))
+
+func toReceipt(rec: ReceiptObject): Receipt =
+  let isHash = if rec.status.isSome: false else: true
+
+  var status = false
+  if rec.status.isSome:
+    if rec.status.get() == 1.Quantity:
+      status = true
+
+  return Receipt(
+    hash: rec.transactionHash,
+    isHash: isHash,
+    status: status,
+    cumulativeGasUsed: rec.cumulativeGasUsed.GasInt,
+    logs: toLogs(rec.logs),
+    logsBloom: rec.logsBloom,
+    receiptType: rec.`type`.get(0.Web3Quantity).ReceiptType,
+  )
+
+func toReceipts(recs: openArray[ReceiptObject]): seq[Receipt] =
+  for r in recs:
+    result.add(toReceipt(r))
+
+proc getReceipts*(
+    vp: VerifiedRpcProxy, blockTag: BlockTag
+): Future[Result[seq[ReceiptObject], string]] {.async.} =
+  let
+    header = (await vp.getHeader(blockTag)).valueOr:
+      return err(error)
+    rxs =
+      try:
+        await vp.rpcClient.eth_getBlockReceipts(blockTag)
+      except CatchableError as e:
+        return err(e.msg)
+
+  if rxs.isSome():
+    if orderedTrieRoot(toReceipts(rxs.get())) != header.receiptsRoot:
+      return
+        err("downloaded receipts do not evaluate to the receipts root of the block")
+  else:
+    return err("error downloading the receipts")
+
+  return ok(rxs.get())
+
+proc getReceipts*(
+    vp: VerifiedRpcProxy, blockHash: Hash32
+): Future[Result[seq[ReceiptObject], string]] {.async.} =
+  let
+    header = (await vp.getHeader(blockHash)).valueOr:
+      return err(error)
+    blockTag =
+      BlockTag(RtBlockIdentifier(kind: bidNumber, number: Quantity(header.number)))
+    rxs =
+      try:
+        await vp.rpcClient.eth_getBlockReceipts(blockTag)
+      except CatchableError as e:
+        return err(e.msg)
+
+  if rxs.isSome():
+    if orderedTrieRoot(toReceipts(rxs.get())) != header.receiptsRoot:
+      return
+        err("downloaded receipts do not evaluate to the receipts root of the block")
+  else:
+    return err("error downloading the receipts")
+
+  return ok(rxs.get())
+
+proc getLogs*(
+    vp: VerifiedRpcProxy, filterOptions: FilterOptions
+): Future[Result[seq[LogObject], string]] {.async.} =
+  let logObjs =
+    try:
+      await vp.rpcClient.eth_getLogs(filterOptions)
+    except CatchableError as e:
+      return err(e.msg)
+
+  var res = newSeq[LogObject]()
+
+  # store block hashes contains the logs so that we can batch receipt requests
+  for lg in logObjs:
+    if lg.blockHash.isSome():
+      let lgBlkHash = lg.blockHash.get()
+      # TODO: a cache will solve downloading the same block receipts for multiple logs
+      var rxs = (await vp.getReceipts(lgBlkHash)).valueOr:
+          return err(error)
+
+      if lg.transactionIndex.isNone():
+        for rx in rxs:
+          for rxLog in rx.logs:
+            # only add verified logs
+            if rxLog.address == lg.address and rxLog.data == lg.data and
+                rxLog.topics == lg.topics:
+              res.add(lg)
+      else:
+        let
+          txIdx = lg.transactionIndex.get()
+          rx = rxs[distinctBase(txIdx)]
+
+        # only add verified logs
+        for rxLog in rx.logs:
+          if rxLog.address == lg.address and rxLog.data == lg.data and rxLog.topics == lg.topics:
+            res.add(lg)
+
+  if res.len == 0:
+    return err("no logs could be verified")
+
+  return ok(res)

nimbus_verified_proxy/rpc/rpc_eth_api.nim

@@ -16,7 +16,9 @@ import
   ../types,
   ../header_store,
   ./accounts,
-  ./blocks
+  ./blocks,
+  ./transactions,
+  ./receipts
 
 logScope:
   topics = "verified_proxy"
@@ -138,13 +140,54 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
 
     x.tx
 
+  vp.proxy.rpc("eth_getTransactionByHash") do(txHash: Hash32) -> TransactionObject:
+    let tx =
+      try:
+        await vp.rpcClient.eth_getTransactionByHash(txHash)
+      except CatchableError as e:
+        raise newException(ValueError, e.msg)
+    if tx.hash != txHash:
+      raise newException(
+        ValueError,
+        "the downloaded transaction hash doesn't match the requested transaction hash",
+      )
+
+    if not checkTxHash(tx, txHash):
+      raise
+        newException(ValueError, "the transaction doesn't hash to the provided hash")
+
+    return tx
+
+  vp.proxy.rpc("eth_getBlockReceipts") do(blockTag: BlockTag) -> Opt[seq[ReceiptObject]]:
+    let rxs = (await vp.getReceipts(blockTag)).valueOr:
+      raise newException(ValueError, error)
+    return Opt.some(rxs)
+
+  vp.proxy.rpc("eth_getTransactionReceipt") do(txHash: Hash32) -> ReceiptObject:
+    let
+      rx =
+        try:
+          await vp.rpcClient.eth_getTransactionReceipt(txHash)
+        except CatchableError as e:
+          raise newException(ValueError, e.msg)
+      rxs = (await vp.getReceipts(rx.blockHash)).valueOr:
+        raise newException(ValueError, error)
+
+    for r in rxs:
+      if r.transactionHash == txHash:
+        return r
+
+    raise newException(ValueError, "receipt couldn't be verified")
+
+  vp.proxy.rpc("eth_getLogs") do(filterOptions: FilterOptions) -> seq[LogObject]:
+    (await vp.getLogs(filterOptions)).valueOr:
+      raise newException(ValueError, error)
+
   # TODO:
   # Following methods are forwarded directly to the web3 provider and therefore
   # are not validated in any way.
   vp.proxy.registerProxyMethod("net_version")
-  vp.proxy.registerProxyMethod("eth_call")
   vp.proxy.registerProxyMethod("eth_sendRawTransaction")
-  vp.proxy.registerProxyMethod("eth_getTransactionReceipt")
 
 # Used to be in eth1_monitor.nim; not sure why it was deleted,
 # so I copied it here. --Adam