feat(contract_manager): latency script for entropy v2 (#1494)

* latency script for entropy v2

* add block number difference

* correct desc

* refactor request randomness

* refactor and use chain as arg instead of contract

* unnecessary condition

* js doc

* correct desc

* use blockhash

contract_manager/scripts/common.ts

@@ -1,4 +1,4 @@
-import { DefaultStore, EvmChain, PrivateKey } from "../src";
+import { DefaultStore, EvmChain, EvmEntropyContract, PrivateKey } from "../src";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import Web3 from "web3";
@@ -181,3 +181,34 @@ export function getSelectedChains(argv: {
   }
   return selectedChains;
 }
+
+/**
+ * Finds the entropy contract for a given EVM chain.
+ * @param {EvmChain} chain The EVM chain to find the entropy contract for.
+ * @returns The entropy contract for the given EVM chain.
+ * @throws {Error} an error if the entropy contract is not found for the given EVM chain.
+ */
+export function findEntropyContract(chain: EvmChain): EvmEntropyContract {
+  for (const contract of Object.values(DefaultStore.entropy_contracts)) {
+    if (contract.getChain().getId() === chain.getId()) {
+      return contract;
+    }
+  }
+  throw new Error(`Entropy contract not found for chain ${chain.getId()}`);
+}
+
+/**
+ * Finds an EVM chain by its name.
+ * @param {string} chainName The name of the chain to find.
+ * @returns The EVM chain instance.
+ * @throws {Error} an error if the chain is not found or is not an EVM chain.
+ */
+export function findEvmChain(chainName: string): EvmChain {
+  const chain = DefaultStore.chains[chainName];
+  if (!chain) {
+    throw new Error(`Chain ${chainName} not found`);
+  } else if (!(chain instanceof EvmChain)) {
+    throw new Error(`Chain ${chainName} is not an EVM chain`);
+  }
+  return chain;
+}

contract_manager/scripts/latency_entropy.ts

@@ -1,33 +1,32 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { DefaultStore, toPrivateKey } from "../src";
-import { COMMON_DEPLOY_OPTIONS } from "./common";
+import { toPrivateKey } from "../src";
+import {
+  COMMON_DEPLOY_OPTIONS,
+  findEntropyContract,
+  findEvmChain,
+} from "./common";
 
 const parser = yargs(hideBin(process.argv))
   .usage(
     "Requests and reveals a random number from an entropy contract while measuing the\n" +
       "latency between request submission and availablity of the provider revelation from fortuna.\n" +
-      "Usage: $0 --contract <entropy_contract_id> --private-key <private-key>"
+      "Usage: $0 --chain <chain-id> --private-key <private-key>"
   )
   .options({
-    contract: {
+    chain: {
       type: "string",
       demandOption: true,
-      desc: "Contract to test latency for",
+      desc: "test latency for the contract on this chain",
     },
     "private-key": COMMON_DEPLOY_OPTIONS["private-key"],
   });
 
 async function main() {
   const argv = await parser.argv;
-  const contract = DefaultStore.entropy_contracts[argv.contract];
-  if (!contract) {
-    throw new Error(
-      `Contract ${argv.contract} not found. Contracts found: ${Object.keys(
-        DefaultStore.entropy_contracts
-      )}`
-    );
-  }
+  const chain = findEvmChain(argv.chain);
+  const contract = findEntropyContract(chain);
+
   const provider = await contract.getDefaultProvider();
   const providerInfo = await contract.getProviderInfo(provider);
   const userRandomNumber = contract.generateUserRandomNumber();

contract_manager/scripts/latency_entropy_with_callback.ts

@@ -0,0 +1,87 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { toPrivateKey } from "../src";
+import {
+  COMMON_DEPLOY_OPTIONS,
+  findEntropyContract,
+  findEvmChain,
+} from "./common";
+import Web3 from "web3";
+
+const parser = yargs(hideBin(process.argv))
+  .usage(
+    "Requests a random number from an entropy contract and measures the\n" +
+      "latency between request submission and fulfillment by the Fortuna keeper service.\n" +
+      "Usage: $0 --chain-id <chain-id> --private-key <private-key>"
+  )
+  .options({
+    chain: {
+      type: "string",
+      demandOption: true,
+      desc: "test latency for the contract on this chain",
+    },
+    "private-key": COMMON_DEPLOY_OPTIONS["private-key"],
+  });
+
+async function main() {
+  const argv = await parser.argv;
+
+  const chain = findEvmChain(argv.chain);
+  const contract = findEntropyContract(chain);
+
+  const provider = await contract.getDefaultProvider();
+  const userRandomNumber = contract.generateUserRandomNumber();
+  const privateKey = toPrivateKey(argv.privateKey);
+  const requestResponse = await contract.requestRandomness(
+    userRandomNumber,
+    provider,
+    privateKey,
+    true // with callback
+  );
+  console.log(`Request tx hash  : ${requestResponse.transactionHash}`);
+  // Read the sequence number for the request from the transaction events.
+  const sequenceNumber =
+    requestResponse.events.RequestedWithCallback.returnValues.sequenceNumber;
+  console.log(`sequence         : ${sequenceNumber}`);
+
+  const startTime = Date.now();
+
+  let fromBlock = requestResponse.blockNumber;
+  const web3 = new Web3(contract.chain.getRpcUrl());
+  const entropyContract = contract.getContract();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const currentBlock = await web3.eth.getBlockNumber();
+
+    if (fromBlock > currentBlock) {
+      continue;
+    }
+
+    const events = await entropyContract.getPastEvents("RevealedWithCallback", {
+      fromBlock: fromBlock,
+      toBlock: currentBlock,
+    });
+    fromBlock = currentBlock + 1;
+
+    const event = events.find(
+      (event) => event.returnValues.request[1] == sequenceNumber
+    );
+
+    if (event !== undefined) {
+      console.log(`Random number    : ${event.returnValues.randomNumber}`);
+      const endTime = Date.now();
+      console.log(`Fortuna Latency  : ${endTime - startTime}ms`);
+      console.log(
+        `Revealed after   : ${
+          currentBlock - requestResponse.blockNumber
+        } blocks`
+      );
+      break;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+  }
+}
+
+main();

contract_manager/src/contracts/evm.ts

@@ -592,19 +592,30 @@ export class EvmEntropyContract extends Storable {
   async requestRandomness(
     userRandomNumber: string,
     provider: string,
-    senderPrivateKey: PrivateKey
+    senderPrivateKey: PrivateKey,
+    withCallback?: boolean
   ) {
     const web3 = new Web3(this.chain.getRpcUrl());
     const userCommitment = web3.utils.keccak256(userRandomNumber);
     const contract = new web3.eth.Contract(EXTENDED_ENTROPY_ABI, this.address);
     const fee = await contract.methods.getFee(provider).call();
     const { address } = web3.eth.accounts.wallet.add(senderPrivateKey);
-    const useBlockHash = false;
-    const transactionObject = contract.methods.request(
-      provider,
-      userCommitment,
-      useBlockHash
-    );
+
+    let transactionObject;
+    if (withCallback) {
+      transactionObject = contract.methods.requestWithCallback(
+        provider,
+        userCommitment
+      );
+    } else {
+      const useBlockHash = false;
+      transactionObject = contract.methods.request(
+        provider,
+        userCommitment,
+        useBlockHash
+      );
+    }
+
     return this.chain.estiamteAndSendTransaction(transactionObject, {
       from: address,
       value: fee,