chore: benchmark for proof generation and verification (#3567)

apps/benchmarks/benchmarks.nim

@@ -11,32 +11,27 @@ import
   ],
   tests/waku_rln_relay/utils_onchain
 
-proc main(): Future[string] {.async, gcsafe.} =
+proc benchmark(
-  # Spin up a local Ethereum JSON-RPC (Anvil) and deploy the RLN contract
+    manager: OnChainGroupManager, registerCount: int, messageLimit: int
-  let anvilProc = runAnvil()
+): Future[string] {.async, gcsafe.} =
-  defer:
-    stopAnvil(anvilProc)
-
-  # Set up an On-chain group manager (includes contract deployment)
-  let manager = await setupOnchainGroupManager()
-  (await manager.init()).isOkOr:
-    raiseAssert $error
-
   # Register a new member so that we can later generate proofs
-  let idCredentials = generateCredentials(manager.rlnInstance)
+  let idCredentials = generateCredentials(manager.rlnInstance, registerCount)
 
-  try:
+  var start_time = getTime()
-    await manager.register(idCredentials, UserMessageLimit(100))
+  for i in 0 .. registerCount - 1:
-  except Exception, CatchableError:
+    try:
-    assert false, "exception raised: " & getCurrentExceptionMsg()
+      await manager.register(idCredentials[i], UserMessageLimit(messageLimit + 1))
+    except Exception, CatchableError:
+      assert false, "exception raised: " & getCurrentExceptionMsg()
 
-  let rootUpdated = await manager.updateRoots()
+    debug "registration finished",
+      iter = i, elapsed_ms = (getTime() - start_time).inMilliseconds
 
-  if rootUpdated:
+  discard await manager.updateRoots()
-    let proofResult = await manager.fetchMerkleProofElements()
+  let proofResult = await manager.fetchMerkleProofElements()
-    if proofResult.isErr():
+  if proofResult.isErr():
-      error "Failed to fetch Merkle proof", error = proofResult.error
+    error "Failed to fetch Merkle proof", error = proofResult.error
-    manager.merkleProofCache = proofResult.get()
+  manager.merkleProofCache = proofResult.get()
 
   let epoch = default(Epoch)
   debug "epoch in bytes", epochHex = epoch.inHex()
@@ -45,22 +40,35 @@ proc main(): Future[string] {.async, gcsafe.} =
   var proofGenTimes: seq[times.Duration] = @[]
   var proofVerTimes: seq[times.Duration] = @[]
 
-  for i in 1 .. 100:
+  start_time = getTime()
-    var time = getTime()
+  for i in 1 .. messageLimit:
+    var generate_time = getTime()
     let proof = manager.generateProof(data, epoch, MessageId(i.uint8)).valueOr:
       raiseAssert $error
-    proofGenTimes.add(getTime() - time)
+    proofGenTimes.add(getTime() - generate_time)
 
-    time = getTime()
+    let verify_time = getTime()
     let ok = manager.verifyProof(data, proof).valueOr:
       raiseAssert $error
-    proofVerTimes.add(getTime() - time)
+    proofVerTimes.add(getTime() - verify_time)
+    debug "iteration finished",
+      iter = i, elapsed_ms = (getTime() - start_time).inMilliseconds
 
   echo "Proof generation times: ", sum(proofGenTimes) div len(proofGenTimes)
   echo "Proof verification times: ", sum(proofVerTimes) div len(proofVerTimes)
 
+proc main() =
+  # Start a local Ethereum JSON-RPC (Anvil) so that the group-manager setup can connect.
+  let anvilProc = runAnvil()
+  defer:
+    stopAnvil(anvilProc)
+
+  # Set up an On-chain group manager (includes contract deployment)
+  let manager = waitFor setupOnchainGroupManager()
+  (waitFor manager.init()).isOkOr:
+    raiseAssert $error
+
+  discard waitFor benchmark(manager, 200, 20)
+
 when isMainModule:
-  try:
+  main()
-    discard waitFor main()
-  except CatchableError as e:
-    raise e

tests/waku_rln_relay/utils_onchain.nim

@@ -585,12 +585,12 @@ proc setupOnchainGroupManager*(
   # If the generated account wishes to register a membership, it needs to approve the contract to spend its tokens
   let tokenApprovalResult = await approveTokenAllowanceAndVerify(
     web3,
-    acc, # owner
+    acc,
     privateKey,
-    testTokenAddress, # ERC20 token address
+    testTokenAddress,
-    contractAddress, # spender - the proxy contract that will spend the tokens
+    contractAddress,
     ethToWei(200.u256),
-    some(0.u256), # expected allowance before approval
+    some(0.u256),
   )
 
   assert tokenApprovalResult.isOk, tokenApprovalResult.error()