move hard-coded parameters to test files

tests/incentivization/test_all.nim

@@ -1,4 +1,3 @@
 import
   ./test_rpc_codec,
-  ./test_eligibility,
   ./test_poc

tests/incentivization/test_eligibility.nim

@@ -1,22 +0,0 @@
-import
-  std/options,
-  testutils/unittests,
-  chronos
-
-import
-  ../../../waku/incentivization/[rpc, common, txid_proof]
-
-
-suite "Waku Incentivization Eligibility Testing":
-
-    asyncTest "check eligibility success with a txid-based proof":
-      let eligibilityProof = genTxIdEligibilityProof(true)
-      let isValid = await txidEligiblityCriteriaMet(eligibilityProof)
-      check:
-        isValid
-
-    asyncTest "check eligibility failure with a txid-based proof":
-      let eligibilityProof = genTxIdEligibilityProof(false)
-      let isValid = await txidEligiblityCriteriaMet(eligibilityProof)
-      check:
-        not isValid

tests/incentivization/test_poc.nim

@@ -5,7 +5,8 @@ import
   testutils/unittests,
   chronicles,
   chronos,
-  libp2p/crypto/crypto
+  libp2p/crypto/crypto,
+  web3
 
 import
   ../../../waku/[
@@ -23,13 +24,24 @@ import
   ]
 
 
+# a random confirmed txis (Sepolia)
+const TxHashExisting* = TxHash.fromHex(
+  "0xc1be5f442d3688a8d3e4b5980a73f15e4351358e0f16e2fdd99c2517c9cf6270"
+  )
+const TxHashNonExisting* = TxHash.fromHex(
+  "0x0000000000000000000000000000000000000000000000000000000000000000"
+  )
+
+const EthClient = "https://sepolia.infura.io/v3/470c2e9a16f24057aee6660081729fb9"
+
 proc newTestDummyProtocolNode*(
   switch: Switch, 
-  handler: DummyHandler
+  handler: DummyHandler,
+  ethClient: string
   ): Future[DummyProtocol] {.async.} =
   let
     peerManager = PeerManager.new(switch)
-    dummyProtocol = DummyProtocol.new(peerManager, handler)
+    dummyProtocol = DummyProtocol.new(peerManager, handler, ethClient)
 
   await dummyProtocol.start()
   switch.mount(dummyProtocol)
@@ -59,7 +71,7 @@ suite "Waku Incentivization PoC Dummy Protocol":
     ): Future[DummyResult[void]] {.async.} =
       handlerFuture.complete(dummyRequest)
       return ok()
-    server = await newTestDummyProtocolNode(serverSwitch, handler)
+    server = await newTestDummyProtocolNode(serverSwitch, handler, EthClient)
 
     # setting up a client
     clientSwitch = newTestSwitch()
@@ -75,13 +87,13 @@ suite "Waku Incentivization PoC Dummy Protocol":
     await allFutures(clientSwitch.stop(), serverSwitch.stop())
 
   asyncTest "incentivization PoC: dummy protocol with a valid txid eligibility proof":
-    let request = genDummyRequestWithTxIdEligibilityProof(true)
+    let request = genDummyRequestWithTxIdEligibilityProof(@(TxHashExisting.bytes()))
     let response = await client.sendRequest(request, serverRemotePeerInfo)
     check:
       response.isOk()
   
   asyncTest "incentivization PoC: dummy protocol client with an invalid txid eligibility proof":
-    let request = genDummyRequestWithTxIdEligibilityProof(false)
+    let request = genDummyRequestWithTxIdEligibilityProof(@(TxHashNonExisting.bytes()))
     let response = await client.sendRequest(request, serverRemotePeerInfo)
     check:
       response.isErr()

tests/incentivization/test_rpc_codec.nim

@@ -2,7 +2,8 @@ import
   std/options,
   testutils/unittests,
   chronos,
-  libp2p/crypto/crypto
+  libp2p/crypto/crypto,
+  web3
 
 import
   ../../../waku/incentivization/[
@@ -13,10 +14,18 @@ import
     eligibility
   ]
 
+let txHash = TxHash.fromHex(
+  "0x0000000000000000000000000000000000000000000000000000000000000000"
+  )
+let txHashAsBytes = @(txHash.bytes())
+
 suite "Waku Incentivization Eligibility Codec":
 
     asyncTest "encode eligibility proof":
-      let eligibilityProof = genTxIdEligibilityProof(true)
+      let txHash = TxHash.fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000000")
+      let txHashAsBytes = @(txHash.bytes())
+      let eligibilityProof = EligibilityProof(proofOfPayment: some(txHashAsBytes))
       let encoded = encode(eligibilityProof)
       let decoded = EligibilityProof.decode(encoded.buffer).get()
       check:
@@ -30,7 +39,10 @@ suite "Waku Incentivization Eligibility Codec":
         eligibilityStatus == decoded
 
     asyncTest "encode dummy request":
-      let dummyRequest = genDummyRequestWithTxIdEligibilityProof(true)
+      let txHash = TxHash.fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000000")
+      let txHashAsBytes = @(txHash.bytes())
+      let dummyRequest = genDummyRequestWithTxIdEligibilityProof(txHashAsBytes)
       let encoded = encode(dummyRequest)
       let decoded = DummyRequest.decode(encoded.buffer).get()
       check:

waku/incentivization/eligibility.nim

@@ -16,8 +16,8 @@ import
   ../../../waku/incentivization/txid_proof
 
 
-proc isEligible*(eligibilityProof: EligibilityProof): Future[bool] {.async.} =
-  result = await txidEligiblityCriteriaMet(eligibilityProof)
+proc isEligible*(eligibilityProof: EligibilityProof, ethClient: string): Future[bool] {.async.} =
+  result = await txidEligiblityCriteriaMet(eligibilityProof, ethClient)
 
 proc genDummyResponseWithEligibilityStatus*(proofValid: bool, requestId: string = ""): DummyResponse = 
   let eligibilityStatus = genEligibilityStatus(proofValid)

waku/incentivization/protocol.nim

@@ -19,6 +19,7 @@ logScope:
 type DummyProtocol* = ref object of LPProtocol
   peerManager*: PeerManager
   dummyHandler*: DummyHandler
+  ethClient*: string
 
 proc handleRequest*(
     dummyProtocol: DummyProtocol, peerId: PeerId, buffer: seq[byte]
@@ -30,7 +31,7 @@ proc handleRequest*(
     let dummyRequest = reqDecodeRes.get()
     let eligibilityProof = dummyRequest.eligibilityProof
     requestId = dummyRequest.requestId
-    isProofValid = await isEligible(eligibilityProof)
+    isProofValid = await isEligible(eligibilityProof, dummyProtocol.ethClient)
   let response = genDummyResponseWithEligibilityStatus(isProofValid, requestId)
   return response
 
@@ -47,10 +48,12 @@ proc new*(
     T: type DummyProtocol,
     peerManager: PeerManager,
     dummyHandler: DummyHandler,
+    ethClient: string,
   ): T =
   let dummyProtocol = DummyProtocol(
     peerManager: peerManager,
     dummyHandler: dummyHandler,
+    ethClient: ethClient
   )
   dummyProtocol.initProtocolHandler()
   return dummyProtocol

waku/incentivization/txid_proof.nim

@@ -6,32 +6,12 @@ import
 
 import ../../../waku/incentivization/rpc
 
-# a random confirmed txis (Sepolia)
-const TxHashExisting* = TxHash.fromHex(
-  "0xc1be5f442d3688a8d3e4b5980a73f15e4351358e0f16e2fdd99c2517c9cf6270"
-  )
-const TxHashNonExisting* = TxHash.fromHex(
-  "0x0000000000000000000000000000000000000000000000000000000000000000"
-  )
-
-const EthClient = "https://sepolia.infura.io/v3/470c2e9a16f24057aee6660081729fb9"
-
-proc genTxIdEligibilityProof*(txIdExists: bool): EligibilityProof = 
-  let txHash: TxHash = (
-    if txIdExists:
-      TxHashExisting
-    else:
-      TxHashNonExisting)
-  let txHashAsBytes = @(txHash.bytes())
-  EligibilityProof(proofOfPayment: some(txHashAsBytes))
-
-proc genDummyRequestWithTxIdEligibilityProof*(proofValid: bool, requestId: string = ""): DummyRequest =
-  let eligibilityProof = genTxIdEligibilityProof(proofValid)
+proc genDummyRequestWithTxIdEligibilityProof*(txHashAsBytes: seq[byte], requestId: string = ""): DummyRequest =
   result.requestId = requestId
-  result.eligibilityProof = eligibilityProof
+  result.eligibilityProof = EligibilityProof(proofOfPayment: some(txHashAsBytes))
 
-proc checkTxIdExists(txHash: TxHash): Future[bool] {.async.} = 
-  let web3 = await newWeb3(EthClient)
+proc checkTxIdExists(txHash: TxHash, ethClient: string): Future[bool] {.async.} = 
+  let web3 = await newWeb3(ethClient)
   try:
     discard await web3.provider.eth_getTransactionByHash(txHash)
     result = true
@@ -40,9 +20,9 @@ proc checkTxIdExists(txHash: TxHash): Future[bool] {.async.} =
   await web3.close()
   result
 
-proc txidEligiblityCriteriaMet*(eligibilityProof: EligibilityProof): Future[bool] {.async.} =
+proc txidEligiblityCriteriaMet*(eligibilityProof: EligibilityProof, ethClient: string): Future[bool] {.async.} =
   if eligibilityProof.proofOfPayment.isNone():
     return false
   let txHash = TxHash.fromHex(byteutils.toHex(eligibilityProof.proofOfPayment.get()))
-  let txExists = await checkTxIdExists(txHash)
+  let txExists = await checkTxIdExists(txHash, ethClient)
   return txExists