resolve filters

Author: chirag-parmar

nimbus_verified_proxy/rpc/blocks.nim

@@ -23,26 +23,26 @@ import
 
 proc resolveBlockTag*(
     vp: VerifiedRpcProxy, blockTag: BlockTag
-): Result[base.BlockNumber, string] =
+): Result[BlockTag, string] =
   if blockTag.kind == bidAlias:
     let tag = blockTag.alias.toLowerAscii()
     case tag
     of "latest":
       let hLatest = vp.headerStore.latest.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(hLatest.number)
+      ok(BlockTag(kind: bidNumber, number: hLatest.number))
     of "finalized":
       let hFinalized = vp.headerStore.finalized.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(hFinalized.number)
+      ok(BlockTag(kind: bidNumber, number: hFinalized.number))
     of "earliest":
       let hEarliest = vp.headerStore.earliest.valueOr:
         return err("Couldn't get the latest block number from header store")
-      ok(hEarliest.number)
+      ok(BlockTag(kind: bidNumber, number: hEarliest.number))
     else:
       err("No support for block tag " & $blockTag)
   else:
-    ok(base.BlockNumber(distinctBase(blockTag.number)))
+    ok(blockTag)
 
 func convHeader*(blk: eth_api_types.BlockObject): Header =
   let nonce = blk.nonce.valueOr:
@@ -184,10 +184,8 @@ proc getBlock*(
 proc getBlock*(
     vp: VerifiedRpcProxy, blockTag: BlockTag, fullTransactions: bool
 ): Future[Result[BlockObject, string]] {.async.} =
-  let
-    n = vp.resolveBlockTag(blockTag).valueOr:
-      return err(error)
-    numberTag = BlockTag(kind: BlockIdentifierKind.bidNumber, number: Quantity(n))
+  let numberTag = vp.resolveBlockTag(blockTag).valueOr:
+    return err(error)
 
   # get the target block
   let blk =
@@ -196,7 +194,7 @@ proc getBlock*(
     except CatchableError as e:
       return err(e.msg)
 
-  if n != distinctBase(blk.number):
+  if numberTag.number != blk.number:
     return
       err("the downloaded block number doesn't match with the requested block number")
 
@@ -235,9 +233,9 @@ proc getHeader*(
     vp: VerifiedRpcProxy, blockTag: BlockTag
 ): Future[Result[Header, string]] {.async.} =
   let
-    n = vp.resolveBlockTag(blockTag).valueOr:
+    numberTag = vp.resolveBlockTag(blockTag).valueOr:
       return err(error)
-    numberTag = BlockTag(kind: BlockIdentifierKind.bidNumber, number: Quantity(n))
+    n = distinctBase(numberTag.number)
     cachedHeader = vp.headerStore.get(n)
 
   if cachedHeader.isNone():

nimbus_verified_proxy/rpc/receipts.nim

@@ -84,37 +84,28 @@ proc getReceipts*(
 
   await vp.getReceipts(header, numberTag)
 
-proc verifyFilterBoundaries*(
-    filter: FilterOptions, logObjs: seq[LogObject]
-): Result[bool, string] =
+proc resolveFilterTags*(filter: FilterOptions): Result[FilterOptions, string] =
   let
-    fromBlock = filter.fromBlock.get(
-      BlockTag(kind: BlockIdentifierKind.bidAlias, alias: "latest")
-    )
-    toBlock =
-      filter.toBlock.get(BlockTag(kind: BlockIdentifierKind.bidAlias, alias: "latest"))
-
-    bottom =
-      if fromBlock.kind == BlockIdentifierKind.bidNumber:
-        fromBlock.number
-      else:
-        return err("Cannot verify boundaries for block tags in 'fromBlock' field")
-    top =
-      if toBlock.kind == BlockIdentifierKind.bidNumber:
-        toBlock.number
-      else:
-        return err("Cannot verify boundaries for block tags in 'toBlock' field")
-
-  for lg in logObjs:
-    if lg.blockNumber.isSome:
-      if lg.blockNumber.get < bottom or lg.blockNumber.get > top:
-        return ok(false)
+    fromBlock = filter.fromBlock.get(types.BlockTag(kind: bidAlias, alias: "latest"))
+    toBlock = filter.toBlock.get(types.BlockTag(kind: bidAlias, alias: "latest"))
+    fromBlockNumberTag = resolveBlockTag(fromBlock).valueOr:
+      return err(error)
+    toBlockNumberTag = resolveBlockTag(toBlock).valueOr:
+      return err(error)
 
-  return ok(true)
+  return ok(
+    FilterOptions(
+      fromBlock: Opt.some(fromBlockNumberTag),
+      toBlock: Opt.some(toBlockNumberTag),
+      address: filter.address,
+      topics: filter.topics,
+      blockHash: filter.blockHash,
+    )
+  )
 
 proc verifyLogs*(
-    vp: VerifiedRpcProxy, logObjs: seq[LogObject]
-): Future[Result[seq[LogObject], string]] {.async.} =
+    vp: VerifiedRpcProxy, filterOptions: FilterOptions, logObjs: seq[LogObject]
+): Future[Result[bool, string]] {.async.} =
   var res = newSeq[LogObject]()
 
   # store block hashes contains the logs so that we can batch receipt requests
@@ -140,7 +131,9 @@ proc verifyLogs*(
 
       if rxLog.address != lg.address or rxLog.data != lg.data or
           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)):
         return err("one of the returned logs is invalid")
 
-  return ok(logObjs)
+  return ok()

nimbus_verified_proxy/rpc/rpc_eth_api.nim

@@ -273,27 +273,23 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
 
   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(filterOptions)
+          await vp.rpcClient.eth_getLogs(filter)
         except CatchableError as e:
           raise newException(ValueError, e.msg)
 
-      boundsCheck = verifyFilterBoundaries(filterOptions, logObjs).valueOr:
-        raise newException(ValueError, error)
-
-    if not boundsCheck:
-      raise newException(ValueError, "Logs out of filter block range")
-
-    let verifiedLogs = (await vp.verifyLogs(logObjs)).valueOr:
-      raise newException(ValueError, error)
+    ?(await vp.verifyLogs(filter, logObjs))
 
-    return verifiedLogs
+    return logObjs
 
   vp.proxy.rpc("eth_newFilter") do(filterOptions: FilterOptions) -> int:
     let
       hexId =
         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)
@@ -319,45 +315,35 @@ proc installEthApiHandlers*(vp: VerifiedRpcProxy) =
       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(vp.filterStore[filterId])
+          await vp.rpcClient.eth_getLogs(filter)
         except CatchableError as e:
           raise newException(ValueError, e.msg)
 
-      boundsCheck = verifyFilterBoundaries(vp.filterStore[filterId], logObjs).valueOr:
-        raise newException(ValueError, error)
+    ?(await vp.verifyLogs(filter, logObjs))
 
-    if not boundsCheck:
-      raise newException(ValueError, "Logs out of filter block range")
-
-    let verifiedLogs = (await vp.verifyLogs(logObjs)).valueOr:
-      raise newException(ValueError, error)
-
-    return verifiedLogs
+    return logObjs
 
   vp.proxy.rpc("eth_getFilterChanges") do(filterId: int) -> 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:
           await vp.rpcClient.eth_getFilterChanges("0x" & toHex(filterId))
         except CatchableError as e:
           raise newException(ValueError, e.msg)
 
-      boundsCheck = verifyFilterBoundaries(vp.filterStore[filterId], logObjs).valueOr:
-        raise newException(ValueError, error)
-
-    if not boundsCheck:
-      raise newException(ValueError, "Logs out of filter block range")
-
-    let verifiedLogs = (await vp.verifyLogs(logObjs)).valueOr:
-      raise newException(ValueError, error)
+    ?(await vp.verifyLogs(filter, logObjs))
 
-    return verifiedLogs
+    return logObjs
 
   # Following methods are forwarded directly to the web3 provider and therefore
   # are not validated in any way.