remove bugs

Author: chirag-parmar

nimbus_verified_proxy/rpc/blocks.nim

@@ -30,15 +30,15 @@ proc resolveBlockTag*(
     of "latest":
       let hLatest = vp.headerStore.latest.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(BlockTag(kind: bidNumber, number: hLatest.number))
+      ok(BlockTag(kind: bidNumber, number: Quantity(hLatest.number)))
     of "finalized":
       let hFinalized = vp.headerStore.finalized.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(BlockTag(kind: bidNumber, number: hFinalized.number))
+      ok(BlockTag(kind: bidNumber, number: Quantity(hFinalized.number)))
     of "earliest":
       let hEarliest = vp.headerStore.earliest.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(BlockTag(kind: bidNumber, number: hEarliest.number))
+      ok(BlockTag(kind: bidNumber, number: Quantity(hEarliest.number)))
     else:
       err("No support for block tag " & $blockTag)
   else:

nimbus_verified_proxy/rpc/receipts.nim

@@ -84,13 +84,15 @@ proc getReceipts*(
 
   await vp.getReceipts(header, numberTag)
 
-proc resolveFilterTags*(filter: FilterOptions): Result[FilterOptions, string] =
+proc resolveFilterTags*(vp: VerifiedRpcProxy, filter: FilterOptions): Result[FilterOptions, string] =
+  if filter.blockHash.isSome():
+    return ok(filter)
   let
     fromBlock = filter.fromBlock.get(types.BlockTag(kind: bidAlias, alias: "latest"))
     toBlock = filter.toBlock.get(types.BlockTag(kind: bidAlias, alias: "latest"))
-    fromBlockNumberTag = resolveBlockTag(fromBlock).valueOr:
+    fromBlockNumberTag = vp.resolveBlockTag(fromBlock).valueOr:
       return err(error)
-    toBlockNumberTag = resolveBlockTag(toBlock).valueOr:
+    toBlockNumberTag = vp.resolveBlockTag(toBlock).valueOr:
       return err(error)
 
   return ok(
@@ -104,9 +106,8 @@ proc resolveFilterTags*(filter: FilterOptions): Result[FilterOptions, string] =
   )
 
 proc verifyLogs*(
-    vp: VerifiedRpcProxy, filterOptions: FilterOptions, logObjs: seq[LogObject]
-): Future[Result[bool, string]] {.async.} =
-  var res = newSeq[LogObject]()
+   vp: VerifiedRpcProxy, filter: FilterOptions, logObjs: seq[LogObject]
+): Future[Result[void, string]] {.async.} =
 
   # store block hashes contains the logs so that we can batch receipt requests
   var
@@ -120,7 +121,7 @@ proc verifyLogs*(
       if prevBlockHash != lg.blockHash.get():
         # TODO: a cache will solve downloading the same block receipts for multiple logs
         rxs = (await vp.getReceipts(lg.blockHash.get())).valueOr:
-          return err(error)
+          return err("Couldn't get block receipt to verify logs")
         prevBlockHash = lg.blockHash.get()
       let
         txIdx = distinctBase(lg.transactionIndex.get())
@@ -133,7 +134,21 @@ proc verifyLogs*(
           rxLog.topics != lg.topics or
           lg.blockNumber.get() < filter.fromBlock.get().number or
           lg.blockNumber.get() > filter.toBlock.get().number or
-          (not match(toLog(lg), filterOptions.address, filterOptions.topics)):
+          (not match(toLog(lg), filter.address, filter.topics)):
         return err("one of the returned logs is invalid")
 
-  return ok()
+  ok()
+
+proc getLogs*(vp: VerifiedRpcProxy, filter: FilterOptions): Future[Result[seq[LogObject], string]] {.async.} =
+  let
+    resolvedFilter = vp.resolveFilterTags(filter).valueOr:
+      return err(error)
+    logObjs =
+      try:
+        await vp.rpcClient.eth_getLogs(resolvedFilter)
+      except CatchableError as e:
+        return err(e.msg)
+
+  ?(await vp.verifyLogs(resolvedFilter, logObjs))
+
+  return ok(logObjs)

nimbus_verified_proxy/rpc/rpc_eth_api.nim

@@ -272,36 +272,25 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
     raise newException(ValueError, "receipt couldn't be verified")
 
   vp.proxy.rpc("eth_getLogs") do(filterOptions: FilterOptions) -> seq[LogObject]:
-    let
-      filter = resolveFilterTags(filterOptions).valueOr:
-        raise newException(ValueError, error)
-      logObjs =
-        try:
-          await vp.rpcClient.eth_getLogs(filter)
-        except CatchableError as e:
-          raise newException(ValueError, e.msg)
-
-    ?(await vp.verifyLogs(filter, logObjs))
-
-    return logObjs
+   (await vp.getLogs(filterOptions)).valueOr:
+      raise newException(ValueError, error)
 
-  vp.proxy.rpc("eth_newFilter") do(filterOptions: FilterOptions) -> int:
+  vp.proxy.rpc("eth_newFilter") do(filterOptions: FilterOptions) -> string:
     let
-      hexId =
+      id =
         try:
           # filter is not resolved when storing only while fetching
           await vp.rpcClient.eth_newFilter(filterOptions)
         except CatchableError as e:
           raise newException(ValueError, e.msg)
-      id = fromHex[int](hexId)
 
     vp.filterStore[id] = filterOptions
     return id
 
-  vp.proxy.rpc("eth_uninstallFilter") do(filterId: int) -> bool:
+  vp.proxy.rpc("eth_uninstallFilter") do(filterId: string) -> bool:
     let status =
       try:
-        await vp.rpcClient.eth_uninstallFilter("0x" & toHex(filterId))
+        await vp.rpcClient.eth_uninstallFilter(filterId)
       except CatchableError as e:
         raise newException(ValueError, e.msg)
 
@@ -310,40 +299,33 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
 
     return status
 
-  vp.proxy.rpc("eth_getFilterLogs") do(filterId: int) -> seq[LogObject]:
+  vp.proxy.rpc("eth_getFilterLogs") do(filterId: string) -> seq[LogObject]:
     if filterId notin vp.filterStore:
       raise newException(ValueError, "Filter doesn't exist")
 
-    let
-      filter = resolveFilterTags(vp.filterStore[filterId]).valueOr:
-        raise newException(ValueError, error)
-      logObjs =
-        try:
-          # use locally stored filter and get logs
-          await vp.rpcClient.eth_getLogs(filter)
-        except CatchableError as e:
-          raise newException(ValueError, e.msg)
-
-    ?(await vp.verifyLogs(filter, logObjs))
-
-    return logObjs
+    (await vp.getLogs(vp.filterStore[filterId])).valueOr:
+      raise newException(ValueError, error)
 
-  vp.proxy.rpc("eth_getFilterChanges") do(filterId: int) -> seq[LogObject]:
+  vp.proxy.rpc("eth_getFilterChanges") do(filterId: string) -> seq[LogObject]:
     if filterId notin vp.filterStore:
       raise newException(ValueError, "Filter doesn't exist")
 
     let
-      filter = resolveFilterTags(vp.filterStore[filterId]).valueOr:
+      filter = vp.resolveFilterTags(vp.filterStore[filterId]).valueOr:
         raise newException(ValueError, error)
       logObjs =
         try:
-          await vp.rpcClient.eth_getFilterChanges("0x" & toHex(filterId))
+          await vp.rpcClient.eth_getFilterChanges(filterId)
         except CatchableError as e:
           raise newException(ValueError, e.msg)
 
-    ?(await vp.verifyLogs(filter, logObjs))
+      unmarshalledLogs = logObjs.to(seq[LogObject])
+      verified = (await vp.verifyLogs(filter, unmarshalledLogs))
+
+    if verified.isErr():
+      raise newException(ValueError, verified.error)
 
-    return logObjs
+    return unmarshalledLogs
 
   # Following methods are forwarded directly to the web3 provider and therefore
   # are not validated in any way.

nimbus_verified_proxy/rpc_api_backend.nim

@@ -7,7 +7,7 @@
 
 {.push raises: [], gcsafe.}
 
-import json_rpc/[rpcproxy, rpcclient], web3/[eth_api, eth_api_types], stint, ./types
+import json_rpc/[rpcproxy, rpcclient], web3/[eth_api, eth_api_types], stint, std/json, ./types
 
 proc initNetworkApiBackend*(vp: VerifiedRpcProxy): EthApiBackend =
   let
@@ -59,6 +59,21 @@ proc initNetworkApiBackend*(vp: VerifiedRpcProxy): EthApiBackend =
     ): Future[seq[LogObject]] {.async: (raw: true).} =
       vp.proxy.getClient.eth_getLogs(filterOptions)
 
+    newFilterProc = proc(
+        filterOptions: FilterOptions
+    ): Future[string] {.async: (raw: true).} =
+      vp.proxy.getClient.eth_newFilter(filterOptions)
+
+    uninstallFilterProc = proc(
+        filterId: string
+    ): Future[bool] {.async: (raw: true).} =
+      vp.proxy.getClient.eth_uninstallFilter(filterId)
+
+    getFilterChangesProc = proc(
+        filterId: string
+    ): Future[JsonNode] {.async: (raw: true).} =
+      vp.proxy.getClient.eth_getFilterChanges(filterId)
+
   EthApiBackend(
     eth_chainId: ethChainIdProc,
     eth_getBlockByHash: getBlockByHashProc,
@@ -70,4 +85,7 @@ proc initNetworkApiBackend*(vp: VerifiedRpcProxy): EthApiBackend =
     eth_getLogs: getLogsProc,
     eth_getTransactionByHash: getTransactionByHashProc,
     eth_getTransactionReceipt: getTransactionReceiptProc,
+    eth_newFilter: newFilterProc,
+    eth_uninstallFilter: uninstallFilterProc,
+    eth_getFilterChanges: getFilterChangesProc
   )

nimbus_verified_proxy/types.nim

@@ -12,6 +12,7 @@ import
   json_rpc/[rpcproxy, rpcclient],
   web3/[eth_api, eth_api_types],
   stint,
+  std/json,
   minilru,
   ./header_store,
   ../execution_chain/evm/async_evm
@@ -51,6 +52,10 @@ type
   GetTransactionReceiptProc = proc(txHash: Hash32): Future[ReceiptObject] {.async.}
   GetTransactionByHashProc = proc(txHash: Hash32): Future[TransactionObject] {.async.}
   GetLogsProc = proc(filterOptions: FilterOptions): Future[seq[LogObject]] {.async.}
+  NewFilterProc = proc(filterOptions: FilterOptions): Future[string] {.async.}
+  UninstallFilterProc = proc(filterId: string): Future[bool] {.async.}
+  GetFilterChangesProc = proc(filterid: string): Future[JsonNode] {.async.}
+
 
   EthApiBackend* = object
     eth_chainId*: ChainIdProc
@@ -63,6 +68,9 @@ type
     eth_getTransactionReceipt*: GetTransactionReceiptProc
     eth_getTransactionByHash*: GetTransactionByHashProc
     eth_getLogs*: GetLogsProc
+    eth_newFilter*: NewFilterProc
+    eth_uninstallFilter*: UninstallFilterProc
+    eth_getFilterChanges*: GetFilterChangesProc
 
   VerifiedRpcProxy* = ref object
     evm*: AsyncEvm
@@ -75,7 +83,7 @@ type
 
     # TODO: when the list grows big add a config object instead
     # config parameters
-    filterStore*: Table[int, FilterOptions]
+    filterStore*: Table[string, FilterOptions]
     chainId*: UInt256
     maxBlockWalk*: uint64
 
@@ -92,7 +100,6 @@ proc init*(
     accountsCache: AccountsCache.init(ACCOUNTS_CACHE_SIZE),
     codeCache: CodeCache.init(CODE_CACHE_SIZE),
     storageCache: StorageCache.init(STORAGE_CACHE_SIZE),
-    filterStore: initTable[int, FilterOptions](),
     chainId: chainId,
     maxBlockWalk: maxBlockWalk,
   )