RNG: Chainlink VRF + Fallback mechanism

contracts/deploy/00-home-chain-arbitration.ts

@@ -1,9 +1,10 @@
 import { HardhatRuntimeEnvironment } from "hardhat/types";
-import { DeployFunction } from "hardhat-deploy/types";
+import { DeployFunction, DeployResult } from "hardhat-deploy/types";
 import { BigNumber } from "ethers";
 import getContractAddress from "./utils/getContractAddress";
 import { deployUpgradable } from "./utils/deployUpgradable";
 import { HomeChains, isSkipped, isDevnet } from "./utils";
+import { VRFSubscriptionManagerV2, VRFSubscriptionManagerV2Mock } from "../typechain-types";
 
 const pnkByChain = new Map<HomeChains, string>([
   [HomeChains.ARBITRUM_ONE, "0x330bD769382cFc6d50175903434CCC8D206DCAE5"],
@@ -18,12 +19,30 @@ const randomizerByChain = new Map<HomeChains, string>([
 
 const daiByChain = new Map<HomeChains, string>([[HomeChains.ARBITRUM_ONE, "??"]]);
 const wethByChain = new Map<HomeChains, string>([[HomeChains.ARBITRUM_ONE, "??"]]);
+// https://docs.chain.link/resources/link-token-contracts?parent=vrf#arbitrum
+const linkByChain = new Map<HomeChains, string>([
+  [HomeChains.ARBITRUM_ONE, "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"],
+  [HomeChains.ARBITRUM_GOERLI, "0xd14838A68E8AFBAdE5efb411d5871ea0011AFd28"],
+]);
+
+// https://docs.chain.link/vrf/v2/subscription/supported-networks#arbitrum-mainnet
+const keyHashByChain = new Map<HomeChains, string>([
+  [HomeChains.ARBITRUM_ONE, "0x72d2b016bb5b62912afea355ebf33b91319f828738b111b723b78696b9847b63"], // 30 gwei key Hash
+  [HomeChains.ARBITRUM_GOERLI, "0x83d1b6e3388bed3d76426974512bb0d270e9542a765cd667242ea26c0cc0b730"],
+  [HomeChains.HARDHAT, "0x0000000000000000000000000000000000000000000000000000000000000000"], // arbitrary value
+]);
+
+// https://docs.chain.link/vrf/v2/subscription/supported-networks#arbitrum-mainnet
+const vrfCoordinatorByChain = new Map<HomeChains, string>([
+  [HomeChains.ARBITRUM_ONE, "0x41034678D6C633D8a95c75e1138A360a28bA15d1"],
+  [HomeChains.ARBITRUM_GOERLI, "0x6D80646bEAdd07cE68cab36c27c626790bBcf17f"],
+]);
 
 const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const { ethers, deployments, getNamedAccounts, getChainId } = hre;
   const { deploy, execute } = deployments;
   const { AddressZero } = hre.ethers.constants;
-  const RNG_LOOKAHEAD = 20;
+  const RNG_FALLBACK = 150;
 
   // fallback to hardhat node signers on local network
   const deployer = (await getNamedAccounts()).deployer ?? (await hre.ethers.getSigners())[0].address;
@@ -42,7 +61,18 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
     const erc20Address = await deployERC20AndFaucet(hre, deployer, "WETH");
     wethByChain.set(HomeChains[HomeChains[chainId]], erc20Address);
   }
-
+  if (chainId === HomeChains.HARDHAT) {
+    vrfCoordinatorByChain.set(
+      HomeChains.HARDHAT,
+      (
+        await deploy("VRFCoordinatorV2Mock", {
+          from: deployer,
+          args: [BigNumber.from(10).pow(18), 1000000000], // base_fee: 1 LINK, gas_price_link: 0.000000001 LINK per gas, from chainlink mock scripts
+          log: true,
+        })
+      ).address
+    );
+  }
   if (!randomizerByChain.get(chainId)) {
     const randomizerMock = await deploy("RandomizerMock", {
       from: deployer,
@@ -80,7 +110,7 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
   const maxFreezingTime = devnet ? 600 : 1800;
   const sortitionModule = await deployUpgradable(deployments, "SortitionModule", {
     from: deployer,
-    args: [deployer, klerosCoreAddress, minStakingTime, maxFreezingTime, rng.address, RNG_LOOKAHEAD],
+    args: [deployer, klerosCoreAddress, minStakingTime, maxFreezingTime, rng.address, RNG_FALLBACK],
     log: true,
   }); // nonce (implementation), nonce+1 (proxy)
 
@@ -119,6 +149,82 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
   await execute("KlerosCore", { from: deployer, log: true }, "changeCurrencyRates", pnk, 12225583, 12);
   await execute("KlerosCore", { from: deployer, log: true }, "changeCurrencyRates", dai, 60327783, 11);
   await execute("KlerosCore", { from: deployer, log: true }, "changeCurrencyRates", weth, 1, 1);
+
+  const link = linkByChain.get(Number(await getChainId())) ?? AddressZero; // LINK not needed on hardhat local node
+  const keyHash = keyHashByChain.get(Number(await getChainId())) ?? AddressZero;
+  const requestConfirmations = 3; // Paramater to be fixed, range [1 ; 200] on Arbitrum
+  const callbackGasLimit = 100000; // Parameter to be fixed, 50000 on RandomizerRNG but no external call to sortitionModule.passPhase() in the callback
+  const numWords = 1;
+  const vrfCoordinator = vrfCoordinatorByChain.get(Number(await getChainId())) ?? AddressZero;
+  // Deploy the VRF Subscription Manager contract on Arbitrum, a mock contract on Hardhat node or nothing on other networks.
+  let vrfSubscriptionManager: DeployResult | string;
+  if (vrfCoordinator) {
+    vrfSubscriptionManager =
+      chainId === HomeChains.HARDHAT
+        ? await deploy("VRFSubscriptionManagerV2Mock", {
+            from: deployer,
+            args: [deployer, vrfCoordinator],
+            log: true,
+          })
+        : await deploy("VRFSubscriptionManagerV2", {
+            from: deployer,
+            args: [deployer, vrfCoordinator, link],
+            log: true,
+          });
+  } else {
+    vrfSubscriptionManager = AddressZero;
+  }
+
+  // Execute the setup transactions for using VRF and deploy the Consumer contract on Hardhat node
+  // The Sortition Module rng source is not changed to the VRF Consumer.
+  if (vrfSubscriptionManager) {
+    if (chainId === HomeChains.HARDHAT) {
+      const vrfSubscriptionManagerContract = (await hre.ethers.getContract(
+        "VRFSubscriptionManagerV2Mock"
+      )) as VRFSubscriptionManagerV2Mock;
+      await vrfSubscriptionManagerContract.topUpSubscription(BigNumber.from(10).pow(20)); // 100 LINK
+      const subscriptionId = await vrfSubscriptionManagerContract.subscriptionId();
+      const vrfConsumer = await deployUpgradable(deployments, "VRFConsumerV2", {
+        from: deployer,
+        args: [
+          deployer,
+          vrfCoordinator,
+          sortitionModule.address,
+          keyHash,
+          subscriptionId,
+          requestConfirmations,
+          callbackGasLimit,
+          numWords,
+          AddressZero,
+          AddressZero,
+        ],
+        log: true,
+      });
+      await vrfSubscriptionManagerContract.addConsumer(vrfConsumer.address);
+    }
+  } else {
+    const vrfSubscriptionManagerContract = (await hre.ethers.getContract(
+      "VRFSubscriptionManagerV2"
+    )) as VRFSubscriptionManagerV2;
+    const subscriptionId = await vrfSubscriptionManagerContract.subscriptionId();
+    const vrfConsumer = await deployUpgradable(deployments, "VRFConsumerV2", {
+      from: deployer,
+      args: [
+        deployer,
+        vrfCoordinator,
+        sortitionModule.address,
+        keyHash,
+        subscriptionId,
+        requestConfirmations,
+        callbackGasLimit,
+        numWords,
+        AddressZero,
+        AddressZero,
+      ],
+      log: true,
+    });
+    await vrfSubscriptionManagerContract.addConsumer(vrfConsumer.address);
+  }
 };
 
 deployArbitration.tags = ["Arbitration"];

contracts/deploy/00-rng.ts

@@ -1,6 +1,6 @@
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import { DeployFunction } from "hardhat-deploy/types";
-import { SortitionModule, RandomizerRNG } from "../typechain-types";
+import { SortitionModule } from "../typechain-types";
 import { HomeChains, isSkipped } from "./utils";
 import { deployUpgradable } from "./utils/deployUpgradable";
 
@@ -18,7 +18,6 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
   const { deployments, getNamedAccounts, getChainId } = hre;
   const { deploy, execute } = deployments;
   const { AddressZero } = hre.ethers.constants;
-  const RNG_LOOKAHEAD = 20;
 
   // fallback to hardhat node signers on local network
   const deployer = (await getNamedAccounts()).deployer ?? (await hre.ethers.getSigners())[0].address;
@@ -56,7 +55,7 @@ const deployArbitration: DeployFunction = async (hre: HardhatRuntimeEnvironment)
   });
 
   const sortitionModule = (await hre.ethers.getContract("SortitionModule")) as SortitionModule;
-  await sortitionModule.changeRandomNumberGenerator(rng.address, RNG_LOOKAHEAD);
+  await sortitionModule.changeRandomNumberGenerator(rng.address);
 };
 
 deployArbitration.tags = ["RNG"];

contracts/deploy/upgrade-sortition-module.ts

@@ -11,7 +11,7 @@ enum HomeChains {
 
 const deployUpgradeSortitionModule: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const { deployments, getNamedAccounts, getChainId } = hre;
-  const RNG_LOOKAHEAD = 20;
+  const RNG_FALLBACK = 150;
 
   // fallback to hardhat node signers on local network
   const deployer = (await getNamedAccounts()).deployer ?? (await hre.ethers.getSigners())[0].address;
@@ -32,7 +32,7 @@ const deployUpgradeSortitionModule: DeployFunction = async (hre: HardhatRuntimeE
         1800, // minStakingTime
         1800, // maxFreezingTime
         rng.address,
-        RNG_LOOKAHEAD,
+        RNG_FALLBACK,
       ],
     });
   } catch (err) {

contracts/hardhat.config.ts

@@ -14,6 +14,7 @@ import "hardhat-docgen";
 import "hardhat-contract-sizer";
 import "hardhat-tracer";
 require("./scripts/simulations/tasks");
+require("./scripts/creditLink");
 
 dotenv.config();
 

contracts/scripts/creditLink.ts

@@ -0,0 +1,55 @@
+import { LinkTokenInterface, VRFSubscriptionManagerV2 } from "../typechain-types";
+import { task } from "hardhat/config";
+import { BigNumber } from "ethers";
+
+enum HomeChains {
+  ARBITRUM_ONE = 42161,
+  ARBITRUM_GOERLI = 421613,
+}
+
+// https://docs.chain.link/resources/link-token-contracts?parent=vrf#arbitrum
+const linkByChain = new Map<HomeChains, string>([
+  [HomeChains.ARBITRUM_ONE, "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4"],
+  [HomeChains.ARBITRUM_GOERLI, "0xd14838A68E8AFBAdE5efb411d5871ea0011AFd28"],
+]);
+
+const ONE_LINK_WEI = BigNumber.from(10).pow(18);
+
+task("credit-link", "Credit LINK tokens to the current Chainlink VRF Subscription")
+  .addParam("amount", "(in normal values, not wei!) The amount of LINK tokens to credit")
+  .setAction(async (taskArgs, hre) => {
+    const { deployments, getNamedAccounts, getChainId, ethers } = hre;
+    const { AddressZero } = ethers.constants;
+    const deployer = (await getNamedAccounts()).deployer ?? AddressZero;
+
+    const chainId = Number(await getChainId());
+    if (!HomeChains[chainId]) {
+      console.error(`Aborting: script is not compatible with ${chainId}`);
+      return;
+    } else {
+      console.log("Crediting %d LINK to %s with deployer %s", HomeChains[chainId], deployer);
+    }
+
+    const { amount } = taskArgs;
+    const amountInWei = BigNumber.from(amount).mul(ONE_LINK_WEI);
+
+    // Retrieve LINK token contract from artifact to interact with it
+    const linkTokenAddress = linkByChain.get(Number(await getChainId())) ?? AddressZero;
+    const linkTokenArtifact = await hre.artifacts.readArtifact("LinkTokenInterface");
+    const linkToken = (await ethers.getContractAtFromArtifact(
+      linkTokenArtifact,
+      linkTokenAddress
+    )) as LinkTokenInterface;
+
+    const vrfSubscriptionManagerDeployment = await deployments.get("VRFSubscriptionManagerV2");
+    const vrfSubscriptionManager = (await ethers.getContractAt(
+      "VRFSubscriptionManagerV2",
+      vrfSubscriptionManagerDeployment.address
+    )) as VRFSubscriptionManagerV2;
+
+    // Transfer LINK from deployer to the Subscription Manager
+    await linkToken.transfer(vrfSubscriptionManager.address, amountInWei);
+
+    // // Fund the subscription, sending `amount` LINK tokens
+    await vrfSubscriptionManager.topUpSubscription(amountInWei);
+  });

contracts/scripts/simulations/tasks.ts

@@ -406,8 +406,6 @@ task("simulate:to-freezing-and-generating-phase", "Pass phase from 'staking' to
     if (isNetworkLocal(hre)) {
       const { sortition, randomizerMock, randomizerRng } = await getContracts(hre);
       const { wallet } = await getWallet(hre, walletindex);
-      const numberOfBlocksToMine = Number(await sortition.rngLookahead());
-      await mineBlocks(numberOfBlocksToMine, hre.network);
       await randomizerMock.connect(wallet).relay(randomizerRng.address, 0, utils.randomBytes(32));
     }
   });

contracts/src/arbitration/SortitionModule.sol

@@ -58,7 +58,7 @@ contract SortitionModule is ISortitionModule, UUPSProxiable, Initializable {
     uint256 public disputesWithoutJurors; // The number of disputes that have not finished drawing jurors.
     RNG public rng; // The random number generator.
     uint256 public randomNumber; // Random number returned by RNG.
-    uint256 public rngLookahead; // Minimal block distance between requesting and obtaining a random number.
+    uint256 public rngFallbackTimeout; // Time after which RNG fallback will be used if no random number was received.
     uint256 public delayedStakeWriteIndex; // The index of the last `delayedStake` item that was written to the array. 0 index is skipped.
     uint256 public delayedStakeReadIndex; // The index of the next `delayedStake` item that should be processed. Starts at 1 because 0 index is skipped.
     mapping(bytes32 => SortitionSumTree) sortitionSumTrees; // The mapping trees by keys.
@@ -92,22 +92,22 @@ contract SortitionModule is ISortitionModule, UUPSProxiable, Initializable {
     /// @param _minStakingTime Minimal time to stake
     /// @param _maxDrawingTime Time after which the drawing phase can be switched
     /// @param _rng The random number generator.
-    /// @param _rngLookahead Lookahead value for rng.
+    /// @param _rngFallbackTimeout RNG fallback timeout in seconds.
     function initialize(
         address _governor,
         KlerosCore _core,
         uint256 _minStakingTime,
         uint256 _maxDrawingTime,
         RNG _rng,
-        uint256 _rngLookahead
+        uint256 _rngFallbackTimeout
     ) external reinitializer(1) {
         governor = _governor;
         core = _core;
         minStakingTime = _minStakingTime;
         maxDrawingTime = _maxDrawingTime;
         lastPhaseChange = block.timestamp;
         rng = _rng;
-        rngLookahead = _rngLookahead;
+        rngFallbackTimeout = _rngFallbackTimeout;
         delayedStakeReadIndex = 1;
     }
 
@@ -135,18 +135,22 @@ contract SortitionModule is ISortitionModule, UUPSProxiable, Initializable {
         maxDrawingTime = _maxDrawingTime;
     }
 
-    /// @dev Changes the `_rng` and `_rngLookahead` storage variables.
+    /// @dev Changes the `_rng` storage variable.
     /// @param _rng The new value for the `RNGenerator` storage variable.
-    /// @param _rngLookahead The new value for the `rngLookahead` storage variable.
-    function changeRandomNumberGenerator(RNG _rng, uint256 _rngLookahead) external onlyByGovernor {
+    function changeRandomNumberGenerator(RNG _rng) external onlyByGovernor {
         rng = _rng;
-        rngLookahead = _rngLookahead;
         if (phase == Phase.generating) {
-            rng.requestRandomness(block.number + rngLookahead);
+            rng.requestRandomness(block.number);
             randomNumberRequestBlock = block.number;
         }
     }
 
+    /// @dev Changes the `rngFallbackTimeout` storage variable.
+    /// @param _rngFallbackTimeout The new value for the `rngFallbackTimeout` storage variable.
+    function changeRNGFallbackTimeout(uint256 _rngFallbackTimeout) external onlyByGovernor {
+        rngFallbackTimeout = _rngFallbackTimeout;
+    }
+
     // ************************************* //
     // *         State Modifiers           * //
     // ************************************* //
@@ -158,23 +162,31 @@ contract SortitionModule is ISortitionModule, UUPSProxiable, Initializable {
                 "The minimum staking time has not passed yet."
             );
             require(disputesWithoutJurors > 0, "There are no disputes that need jurors.");
-            rng.requestRandomness(block.number + rngLookahead);
+            rng.requestRandomness(block.number);
             randomNumberRequestBlock = block.number;
             phase = Phase.generating;
+            lastPhaseChange = block.timestamp;
+            emit NewPhase(phase);
         } else if (phase == Phase.generating) {
-            randomNumber = rng.receiveRandomness(randomNumberRequestBlock + rngLookahead);
-            require(randomNumber != 0, "Random number is not ready yet");
-            phase = Phase.drawing;
+            randomNumber = rng.receiveRandomness(randomNumberRequestBlock);
+            if (randomNumber == 0) {
+                if (block.number > randomNumberRequestBlock + rngFallbackTimeout) {
+                    rng.receiveRandomnessFallback(block.number);
+                }
+            } else {
+                phase = Phase.drawing;
+                lastPhaseChange = block.timestamp;
+                emit NewPhase(phase);
+            }
         } else if (phase == Phase.drawing) {
             require(
                 disputesWithoutJurors == 0 || block.timestamp - lastPhaseChange >= maxDrawingTime,
                 "There are still disputes without jurors and the maximum drawing time has not passed yet."
             );
             phase = Phase.staking;
+            lastPhaseChange = block.timestamp;
+            emit NewPhase(phase);
         }
-
-        lastPhaseChange = block.timestamp;
-        emit NewPhase(phase);
     }
 
     /// @dev Create a sortition sum tree at the specified key.

contracts/src/rng/BlockhashRNG.sol

@@ -41,4 +41,6 @@ contract BlockHashRNG is RNG {
         }
         randomNumbers[_block] = randomNumber;
     }
+
+    function receiveRandomnessFallback(uint256 _block) external {}
 }

contracts/src/rng/IncrementalNG.sol

@@ -28,4 +28,6 @@ contract IncrementalNG is RNG {
             return number++;
         }
     }
+
+    function receiveRandomnessFallback(uint256 _block) external {}
 }

contracts/src/rng/RNG.sol

@@ -11,4 +11,6 @@ interface RNG {
     /// @param _block Block the random number is linked to.
     /// @return randomNumber Random Number. If the number is not ready or has not been required 0 instead.
     function receiveRandomness(uint256 _block) external returns (uint256 randomNumber);
+
+    function receiveRandomnessFallback(uint256 _block) external;
 }