@keep-network/tbtc-v2 1.0.0-dev.3 → 1.0.0-dev.5

package/export/deploy/06_deploy_bridge.js

@@ -90,7 +90,8 @@ var func = function (hre) {
                 case 5:
                     ReimbursementPool = _h.sent();
                     txProofDifficultyFactor = deployments.getNetworkName() === "hardhat" ||
-                        deployments.getNetworkName() === "development"
+                        deployments.getNetworkName() === "development" ||
+                        deployments.getNetworkName() === "system_tests"
                         ? 1
                         : 6;
                     deployOptions = {

package/export/tasks/test-utils.js

@@ -37,11 +37,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("hardhat/config");
 var staking_1 = require("../test/integration/utils/staking");
 var ecdsa_wallet_registry_1 = require("../test/integration/utils/ecdsa-wallet-registry");
-(0, config_1.task)("test-utils:register-operators", "Registers operators in the sortition pool")
+var integration_1 = require("../test/integration/data/integration");
+var bls_1 = __importDefault(require("../test/integration/data/bls"));
+var random_beacon_1 = require("../test/integration/utils/random-beacon");
+(0, config_1.task)("test-utils:register-operators", "Registers operators in the sortition pools")
     .addOptionalParam("numberOfOperators", "Number of operators to register", 110, config_1.types.int)
     .addOptionalParam("unnamedSignersOffset", "Offset indicating the unnamed signers", 0, config_1.types.int)
     .addOptionalParam("stakeAmount", "Amount of each operator's stake", "40000000000000000000000", config_1.types.string)
@@ -75,35 +81,58 @@ var ecdsa_wallet_registry_1 = require("../test/integration/utils/ecdsa-wallet-re
 }); });
 function registerOperators(hre, numberOfOperators, unnamedSignersOffset, stakeAmount) {
     return __awaiter(this, void 0, void 0, function () {
-        var helpers, walletRegistry, sortitionPool, t, staking, signers, i, owner, stakingProvider, operator, beneficiary, authorizer;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var helpers, chaosnetOwner, walletRegistry, ecdsaSortitionPool, t, staking, randomBeacon, beaconSortitionPool, signers, i, owner, stakingProvider, operator, beneficiary, authorizer, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     helpers = hre.helpers;
-                    return [4 /*yield*/, helpers.contracts.getContract("WalletRegistry")];
+                    return [4 /*yield*/, helpers.signers.getNamedSigners()];
                 case 1:
-                    walletRegistry = _a.sent();
-                    return [4 /*yield*/, helpers.contracts.getContract("EcdsaSortitionPool")];
+                    chaosnetOwner = (_c.sent()).chaosnetOwner;
+                    return [4 /*yield*/, helpers.contracts.getContract("WalletRegistry")];
                 case 2:
-                    sortitionPool = _a.sent();
-                    return [4 /*yield*/, helpers.contracts.getContract("T")];
+                    walletRegistry = _c.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("EcdsaSortitionPool")];
                 case 3:
-                    t = _a.sent();
-                    return [4 /*yield*/, helpers.contracts.getContract("TokenStaking")];
+                    ecdsaSortitionPool = _c.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("T")];
                 case 4:
-                    staking = _a.sent();
-                    return [4 /*yield*/, helpers.signers.getUnnamedSigners()];
+                    t = _c.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("TokenStaking")];
                 case 5:
-                    signers = (_a.sent()).slice(unnamedSignersOffset);
+                    staking = _c.sent();
+                    return [4 /*yield*/, ecdsaSortitionPool.isChaosnetActive()];
+                case 6:
+                    if (!_c.sent()) return [3 /*break*/, 8];
+                    return [4 /*yield*/, ecdsaSortitionPool.connect(chaosnetOwner).deactivateChaosnet()];
+                case 7:
+                    _c.sent();
+                    _c.label = 8;
+                case 8: return [4 /*yield*/, helpers.contracts.getContract("RandomBeacon")];
+                case 9:
+                    randomBeacon = _c.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("BeaconSortitionPool")];
+                case 10:
+                    beaconSortitionPool = _c.sent();
+                    return [4 /*yield*/, beaconSortitionPool.isChaosnetActive()];
+                case 11:
+                    if (!_c.sent()) return [3 /*break*/, 13];
+                    return [4 /*yield*/, beaconSortitionPool.connect(chaosnetOwner).deactivateChaosnet()];
+                case 12:
+                    _c.sent();
+                    _c.label = 13;
+                case 13: return [4 /*yield*/, helpers.signers.getUnnamedSigners()];
+                case 14:
+                    signers = (_c.sent()).slice(unnamedSignersOffset);
                     // We use unique accounts for each staking role for each operator.
                     if (signers.length < numberOfOperators * 5) {
                         throw new Error("not enough unnamed signers; update hardhat network's configuration account count");
                     }
                     console.log("Starting registration of ".concat(numberOfOperators, " operators"));
                     i = 0;
-                    _a.label = 6;
-                case 6:
-                    if (!(i < numberOfOperators)) return [3 /*break*/, 11];
+                    _c.label = 15;
+                case 15:
+                    if (!(i < numberOfOperators)) return [3 /*break*/, 24];
                     owner = signers[i];
                     stakingProvider = signers[1 * numberOfOperators + i];
                     operator = signers[2 * numberOfOperators + i];
@@ -111,19 +140,32 @@ function registerOperators(hre, numberOfOperators, unnamedSignersOffset, stakeAm
                     authorizer = signers[4 * numberOfOperators + i];
                     console.log("Registering operator ".concat(i, " with address ").concat(operator.address));
                     return [4 /*yield*/, (0, staking_1.stake)(hre, t, staking, stakeAmount, owner, stakingProvider.address, beneficiary.address, authorizer.address)];
-                case 7:
-                    _a.sent();
+                case 16:
+                    _c.sent();
                     return [4 /*yield*/, (0, staking_1.authorizeApplication)(staking, walletRegistry.address, authorizer, stakingProvider.address, stakeAmount)];
-                case 8:
-                    _a.sent();
-                    return [4 /*yield*/, (0, ecdsa_wallet_registry_1.registerOperator)(walletRegistry, sortitionPool, stakingProvider, operator)];
-                case 9:
-                    _a.sent();
-                    _a.label = 10;
-                case 10:
+                case 17:
+                    _c.sent();
+                    return [4 /*yield*/, (0, staking_1.authorizeApplication)(staking, randomBeacon.address, authorizer, stakingProvider.address, stakeAmount)];
+                case 18:
+                    _c.sent();
+                    return [4 /*yield*/, (0, ecdsa_wallet_registry_1.registerOperator)(walletRegistry, ecdsaSortitionPool, stakingProvider, operator)];
+                case 19:
+                    _c.sent();
+                    _b = (_a = randomBeacon
+                        .connect(stakingProvider))
+                        .registerOperator;
+                    return [4 /*yield*/, operator.getAddress()];
+                case 20: return [4 /*yield*/, _b.apply(_a, [_c.sent()])];
+                case 21:
+                    _c.sent();
+                    return [4 /*yield*/, randomBeacon.connect(operator).joinSortitionPool()];
+                case 22:
+                    _c.sent();
+                    _c.label = 23;
+                case 23:
                     i++;
-                    return [3 /*break*/, 6];
-                case 11:
+                    return [3 /*break*/, 15];
+                case 24:
                     console.log("Registered ".concat(numberOfOperators, " sortition pool operators"));
                     return [2 /*return*/];
             }
@@ -132,23 +174,71 @@ function registerOperators(hre, numberOfOperators, unnamedSignersOffset, stakeAm
 }
 function createWallet(hre, walletPublicKey) {
     return __awaiter(this, void 0, void 0, function () {
-        var ethers, helpers, governance, bridge, walletRegistry, walletRegistryGovernance, requestNewWalletTx;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var ethers, helpers, governance, bridge, walletRegistry, walletRegistryGovernance, randomBeacon, randomBeaconGovernance, genesisTx, genesisBlock, genesisSeed, sortitionPool, signers, _a, members, signingMembersIndices, signaturesBytes, membersHash, dkgResult, submitter, requestNewWalletTx;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
                     ethers = hre.ethers, helpers = hre.helpers;
                     return [4 /*yield*/, helpers.signers.getNamedSigners()];
                 case 1:
-                    governance = (_a.sent()).governance;
+                    governance = (_b.sent()).governance;
                     return [4 /*yield*/, helpers.contracts.getContract("Bridge")];
                 case 2:
-                    bridge = _a.sent();
+                    bridge = _b.sent();
                     return [4 /*yield*/, helpers.contracts.getContract("WalletRegistry")];
                 case 3:
-                    walletRegistry = _a.sent();
+                    walletRegistry = _b.sent();
                     return [4 /*yield*/, helpers.contracts.getContract("WalletRegistryGovernance")];
                 case 4:
-                    walletRegistryGovernance = _a.sent();
+                    walletRegistryGovernance = _b.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("RandomBeacon")];
+                case 5:
+                    randomBeacon = _b.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("RandomBeaconGovernance")];
+                case 6:
+                    randomBeaconGovernance = _b.sent();
+                    return [4 /*yield*/, (0, random_beacon_1.updateDkgResultChallengePeriodLength)(hre, governance, randomBeaconGovernance)];
+                case 7:
+                    _b.sent();
+                    return [4 /*yield*/, randomBeacon.genesis()];
+                case 8:
+                    genesisTx = _b.sent();
+                    genesisBlock = genesisTx.blockNumber;
+                    return [4 /*yield*/, (0, random_beacon_1.getGenesisSeed)(hre, genesisBlock)];
+                case 9:
+                    genesisSeed = _b.sent();
+                    return [4 /*yield*/, helpers.time.mineBlocksTo(genesisBlock + integration_1.offchainDkgTime + 1)];
+                case 10:
+                    _b.sent();
+                    return [4 /*yield*/, helpers.contracts.getContract("BeaconSortitionPool")];
+                case 11:
+                    sortitionPool = _b.sent();
+                    return [4 /*yield*/, (0, random_beacon_1.selectGroup)(hre, sortitionPool, genesisSeed)];
+                case 12:
+                    signers = _b.sent();
+                    return [4 /*yield*/, (0, random_beacon_1.signDkgResult)(hre, signers, bls_1.default.groupPubKey, [], genesisBlock, 33)];
+                case 13:
+                    _a = _b.sent(), members = _a.members, signingMembersIndices = _a.signingMembersIndices, signaturesBytes = _a.signaturesBytes;
+                    membersHash = (0, random_beacon_1.hashDKGMembers)(hre, members, []);
+                    dkgResult = {
+                        submitterMemberIndex: 1,
+                        groupPubKey: bls_1.default.groupPubKey,
+                        misbehavedMembersIndices: [],
+                        signatures: signaturesBytes,
+                        signingMembersIndices: signingMembersIndices,
+                        members: members,
+                        membersHash: membersHash,
+                    };
+                    submitter = signers[0].signer;
+                    return [4 /*yield*/, randomBeacon.connect(submitter).submitDkgResult(dkgResult)];
+                case 14:
+                    _b.sent();
+                    return [4 /*yield*/, helpers.time.mineBlocks(integration_1.dkgResultChallengePeriodLength + 1)];
+                case 15:
+                    _b.sent();
+                    return [4 /*yield*/, randomBeacon.connect(submitter).approveDkgResult(dkgResult)];
+                case 16:
+                    _b.sent();
                     return [4 /*yield*/, bridge.requestNewWallet({
                             txHash: ethers.constants.HashZero,
                             txOutputIndex: 0,
@@ -158,8 +248,8 @@ function createWallet(hre, walletPublicKey) {
                         // task environment. In order to provide a relay entry to the registry, we
                         // set the governance as the random beacon and provide a relay entry as usual.
                     ];
-                case 5:
-                    requestNewWalletTx = _a.sent();
+                case 17:
+                    requestNewWalletTx = _b.sent();
                     // Using smock to make a fake RandomBeacon instance does not work in the
                     // task environment. In order to provide a relay entry to the registry, we
                     // set the governance as the random beacon and provide a relay entry as usual.
@@ -168,21 +258,21 @@ function createWallet(hre, walletPublicKey) {
                             .upgradeRandomBeacon(governance.address)
                         // eslint-disable-next-line no-underscore-dangle
                     ];
-                case 6:
+                case 18:
                     // Using smock to make a fake RandomBeacon instance does not work in the
                     // task environment. In order to provide a relay entry to the registry, we
                     // set the governance as the random beacon and provide a relay entry as usual.
-                    _a.sent();
+                    _b.sent();
                     // eslint-disable-next-line no-underscore-dangle
                     return [4 /*yield*/, walletRegistry
                             .connect(governance)
                             .__beaconCallback(ethers.utils.randomBytes(32), 0)];
-                case 7:
+                case 19:
                     // eslint-disable-next-line no-underscore-dangle
-                    _a.sent();
+                    _b.sent();
                     return [4 /*yield*/, (0, ecdsa_wallet_registry_1.performEcdsaDkg)(hre, walletRegistry, walletPublicKey, requestNewWalletTx.blockNumber)];
-                case 8:
-                    _a.sent();
+                case 20:
+                    _b.sent();
                     console.log("Created wallet with public key ".concat(walletPublicKey));
                     return [2 /*return*/];
             }

package/export/test/integration/data/bls.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var blsData = {
+    // data generated using master secret key 123
+    secretKey: 123,
+    // altbn128 public key for secret key 123. For implementation details refer to bls_test.go
+    groupPubKey: "0x1f1954b33144db2b5c90da089e8bde287ec7089d5d6433f3b6becaefdb678b1b2a9de3" +
+        "8d14bef2cf9afc3c698a4211fa7ada7b4f036a2dfef0dc122b423259d01659dc18b57722" +
+        "ecf6a4beb4d04dfe780a660c4c3bb2b165ab8486114c464c621bf37ecdba226629c20908" +
+        "c7f475c5b3a7628ce26d696436eab0b0148034dfcd",
+};
+exports.default = blsData;

package/export/test/integration/data/integration.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offchainDkgTime = exports.dkgResultChallengePeriodLength = exports.governanceDelay = exports.redemptionData = exports.depositSweepData = exports.revealDepositData = exports.NO_MAIN_UTXO = exports.walletPubKeyHash = exports.walletPublicKey = void 0;
+/**
+ * Wallet public key as uncompressed and un-prefixed public key X and Y
+ * coordinates derived from the compressed public key
+ * 03989d253b17a6a0f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d9
+ */
+exports.walletPublicKey = "0x989d253b17a6a0f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d9d218b65" +
+    "e7d91c752f7b22eaceb771a9af3a6f3d3f010a5d471a1aeef7d7713af";
+/**
+ * Wallet public key hash calculated as HASH160 of compressed public key
+ * 03989d253b17a6a0f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d9
+ */
+exports.walletPubKeyHash = "0x8db50eb52063ea9d98b3eac91489a90f738986f6";
+/**
+ * Data used to indicate that the wallet does not have the main UTXO set
+ */
+exports.NO_MAIN_UTXO = {
+    txHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    txOutputIndex: 0,
+    txOutputValue: 0,
+};
+/**
+ * Test data based on a testnet deposit transaction:
+ * https://live.blockcypher.com/btc-testnet/tx/c872fb11bbca1241aced71c692e7d0b0cf46aadb390ce66ddfcf5fbd8e5bc26f/
+ */
+exports.revealDepositData = {
+    fundingTx: {
+        version: "0x01000000",
+        inputVector: "0x0176f251d17d821b938e39b508cd3e02233d71d9b9bfe387a42a050023d3788edb01" +
+            "00000000ffffffff",
+        outputVector: "0x02a08601000000000022002086a303cdd2e2eab1d1679f1a813835dc5a1b65321077" +
+            "cdccaf08f98cbf04ca96ba2c0e0000000000160014e257eccafbc07c381642ce6e7e55" +
+            "120fb077fbed",
+        locktime: "0x00000000",
+    },
+    depositor: "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637",
+    reveal: {
+        fundingOutputIndex: 0,
+        blindingFactor: "0xf9f0c90d00039523",
+        // HASH160 of 03989d253b17a6a0f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d9.
+        walletPubKeyHash: "0x8db50eb52063ea9d98b3eac91489a90f738986f6",
+        // HASH160 of 0300d6f28a2f6bf9836f57fcda5d284c9a8f849316119779f0d6090830d97763a9.
+        refundPubKeyHash: "0xe257eccafbc07c381642ce6e7e55120fb077fbed",
+        refundLocktime: "0xe0250162",
+        vault: "0x0000000000000000000000000000000000000000",
+    },
+};
+/**
+ * Test data based on a deposit sweep transaction:
+ * https://live.blockcypher.com/btc-testnet/tx/0aa0af5a6de05a7be990ca47f7a523df872b29a0f3be3d54cd99a6a6d43a1366/
+ */
+exports.depositSweepData = {
+    sweepTx: {
+        // little endian
+        hash: "0x66133ad4a6a699cd543dbef3a0292b87df23a5f747ca90e97b5ae06d5aafa00a",
+        version: "0x01000000",
+        inputVector: "0x016fc25b8ebd5fcfdf6de60c39dbaa46cfb0d0e792c671edac4112cabb11fb72c80" +
+            "000000000ffffffff",
+        outputVector: "0x0160800100000000001600148db50eb52063ea9d98b3eac91489a90f738986f6",
+        locktime: "0x00000000",
+    },
+    sweepProof: {
+        merkleProof: "0xd2d2ec32d817f4cba2834f129c14cf6a201cc6c7d117e996055ce03d891e6e01fc9" +
+            "9387d8210318ea8f0b1fd3b0b873f17098562dc81ca666587bc57fc656ad30f4093b0" +
+            "0c6e65abe9603552cd9b0ced0c896574f9ecc01297625d2951951e42ffde1c2fbad8e" +
+            "49d263870b9672ff2da607d310717a6e6fe5bc4d5a690da2417e20a39c76cffda21d3" +
+            "e0ce36c1b382e92b78cd09b5c63ba1d7b0098d88148190",
+        txIndexInBlock: 5,
+        bitcoinHeaders: "0x00e0ff3f0b7757387203041464703bb7d3ae57954c8a30003efd084eb3000000000" +
+            "000006c900bb840b7b4cce593dfff74567d5e933ce5f516359549d52c9c9e968a413d" +
+            "4afc8f628886021aff93302f00400020cd4746c5454705245006c0b45be789f6471a8" +
+            "e2078bb7fd637020000000000005bbffa9b6298c97ba38ed8dc3bd0391db26925f686" +
+            "f43a291e52966b780a387556fc8f628886021acfc87ec900008020ab51d62a13dbd5c" +
+            "a691b27ccc0d7e993533e0585ed9ed2a8c2010000000000007c36f5e45f083edc4b8a" +
+            "8219453b32900f601d5b5874004e94cfa99de2d6e2e158fc8f628886021a153aef4b0" +
+            "0a0c3219db742d6b771cc751b754d91b4979adf02e9515ba7fe263292000000000000" +
+            "003a267be82ccf921d65d7ad64bdf94b600de661cb8c5674a4123ef4fdd17b76a2a0f" +
+            "c8f628886021a61450f9600006020594a0c528455406b771150750d67cbc1c436386e" +
+            "2a02e4d933010000000000007c9ce5d550804761ebbc8d533d10f959eda17dc5497ba" +
+            "3dc59eda45c085c005015fd8f628886021a51e22cca00008020f5c97ab8177d24ed69" +
+            "c30e5f47a406b2f28bc4c55ecf7c2475010000000000009924355d4ead5123b9182df" +
+            "f31c16482081ab751ce4de58ab765513cf1ee30c76ffd8f628886021a9334731a0000" +
+            "0020a420df9e874f05566015e8b201a0988280e7affc4f93c2807b020000000000003" +
+            "efbfe9eca35bf2be96866779ae9bc3543587879d3b04cba026e3666c6b1e1280ffe8f" +
+            "628886021a3482464e",
+    },
+    mainUtxo: exports.NO_MAIN_UTXO,
+    chainDifficulty: 6642991,
+};
+/**
+ * Test data based on a testnet redemption transaction:
+ * https://live.blockcypher.com/btc-testnet/tx/14b6c9b70530ff0cabd1d28513bf82a7c2781da0ce3bc50df72e2a1b6745e36e/
+ */
+exports.redemptionData = {
+    redemptionTx: {
+        // little endian
+        hash: "0x6ee345671b2a2ef70dc53bcea01d78c2a782bf1385d2d1ab0cff3005b7c9b614",
+        version: "0x01000000",
+        inputVector: "0x0166133ad4a6a699cd543dbef3a0292b87df23a5f747ca90e97b5ae06d5aafa00a00" +
+            "00000000ffffffff",
+        outputVector: "0x02279c00000000000017a91486884e6be1525dab5ae0b451bd2c72cee67dcf418729" +
+            "bd0000000000001600148db50eb52063ea9d98b3eac91489a90f738986f6",
+        locktime: "0x00000000",
+    },
+    redemptionProof: {
+        merkleProof: "0xbbd3856c4905b3ad333b0c983ec8054037f4aee063ebf11e616a5de184ebadcbb89b" +
+            "63b065209daf4a02c791569e3b8dd9b757ec3ca0987bb8350c4262a3cd23ac4914f3f6" +
+            "3b8662f63c74d4fb45c4d17321b62dfb963be7d86edba9ad0019070462084966bce982" +
+            "617181989be75de2a5d979ec5b9e464b965b32b073d9824d",
+        txIndexInBlock: 3,
+        bitcoinHeaders: "0x0020002075c389e96e3f51146e7721971c3475a9c6c34d65f0570c96040100000000" +
+            "0000b19c82d8511a85bd8ab761c3247b10359b4808a360f505834814a66ac9bc493532" +
+            "d490628886021ae4bc58ab0000e0205ba8b6dbc9549bada90b659462a297769da473b3" +
+            "716016c36a02000000000000bb1d2c391a063c6a7033737ef7aa0f527505dc1f1ad5e9" +
+            "e3a94dd742bf58b98381d490628886021a2f4bc8dd00200020cda405cc32aab0e33d7d" +
+            "44d0bf494288ad77a170ccf98d08820000000000000041e22ae5c9fbee788909afeccd" +
+            "d1afa3bf73e559af3fe54e581d12a1bf5a13ff84d490628886021ac33913c200c03f28" +
+            "67a0223297ab9988f8b0d0aa1b86dcb9d5148644f8fe7b523501000000000000729c46" +
+            "406357331e606a917f5e5bda15f52f279b80deb56ba9a82c5a2533b3e6b7d490628886" +
+            "021a76ee51250000262bed6a4dd34cb4f7dbe3d2635a1aeb53ec4a2e66254e060559ba" +
+            "010000000000007c91333dcdd3f36fbe2e984105046c4f44eafbbad83d1ed83d62c6c4" +
+            "f410b32ec2d490628886021a1bc0509d0000a0207bffc975d2f879018901c33f7c0994" +
+            "5b8456b0da414605ca0a00000000000000426a4dbc2b68663d750cf29e57b9e521895e" +
+            "ad57f73696be93e08d485e05d36fcfd490628886021a786a19ef008000209d30775f9f" +
+            "4f6452fcc83c6a1e54a9010c65b0af1791405989000000000000007b118930c4716d17" +
+            "ea8e5322cf029014be251ac968f38d8cdcfdcdf6cff8e4fdeed490628886021ab1663024",
+    },
+};
+exports.governanceDelay = 604800;
+exports.dkgResultChallengePeriodLength = 100;
+exports.offchainDkgTime = 72;

package/export/test/integration/utils/random-beacon.js

@@ -0,0 +1,193 @@
+"use strict";
+/* eslint-disable no-await-in-loop */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashDKGMembers = exports.signDkgResult = exports.selectGroup = exports.getGenesisSeed = exports.updateDkgResultChallengePeriodLength = void 0;
+var integration_1 = require("../data/integration");
+function updateDkgResultChallengePeriodLength(hre, governance, randomBeaconGovernance) {
+    return __awaiter(this, void 0, void 0, function () {
+        var helpers;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    helpers = hre.helpers;
+                    return [4 /*yield*/, randomBeaconGovernance
+                            .connect(governance)
+                            .beginDkgResultChallengePeriodLengthUpdate(integration_1.dkgResultChallengePeriodLength)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, helpers.time.increaseTime(integration_1.governanceDelay)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, randomBeaconGovernance
+                            .connect(governance)
+                            .finalizeDkgResultChallengePeriodLengthUpdate()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.updateDkgResultChallengePeriodLength = updateDkgResultChallengePeriodLength;
+function getGenesisSeed(hre, genesisBlock) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers;
+        return __generator(this, function (_a) {
+            ethers = hre.ethers;
+            return [2 /*return*/, ethers.BigNumber.from(ethers.utils.keccak256(ethers.utils.solidityPack(["uint256", "uint256"], [
+                    "31415926535897932384626433832795028841971693993751058209749445923078164062862",
+                    genesisBlock,
+                ])))];
+        });
+    });
+}
+exports.getGenesisSeed = getGenesisSeed;
+function selectGroup(hre, sortitionPool, seed) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers, identifiers, addresses;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ethers = hre.ethers;
+                    return [4 /*yield*/, sortitionPool.selectGroup(64, ethers.utils.hexZeroPad(seed.toHexString(), 32))];
+                case 1:
+                    identifiers = _a.sent();
+                    return [4 /*yield*/, sortitionPool.getIDOperators(identifiers)];
+                case 2:
+                    addresses = _a.sent();
+                    return [2 /*return*/, Promise.all(identifiers.map(function (identifier, i) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = {
+                                            id: identifier
+                                        };
+                                        return [4 /*yield*/, ethers.getSigner(addresses[i])];
+                                    case 1: return [2 /*return*/, (_a.signer = _b.sent(),
+                                            _a)];
+                                }
+                            });
+                        }); }))];
+            }
+        });
+    });
+}
+exports.selectGroup = selectGroup;
+function signDkgResult(hre, signers, groupPublicKey, misbehavedMembersIndices, startBlock, numberOfSignatures) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers, hardhatNetworkId, resultHash, members, signingMembersIndices, signatures, i, _a, id, ethersSigner, signerIndex, signature, signaturesBytes;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    ethers = hre.ethers;
+                    hardhatNetworkId = 31337;
+                    resultHash = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["uint256", "bytes", "uint8[]", "uint256"], [hardhatNetworkId, groupPublicKey, misbehavedMembersIndices, startBlock]));
+                    members = [];
+                    signingMembersIndices = [];
+                    signatures = [];
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    if (!(i < signers.length)) return [3 /*break*/, 4];
+                    _a = signers[i], id = _a.id, ethersSigner = _a.signer;
+                    members.push(id);
+                    if (signatures.length === numberOfSignatures) {
+                        // eslint-disable-next-line no-continue
+                        return [3 /*break*/, 3];
+                    }
+                    signerIndex = i + 1;
+                    signingMembersIndices.push(signerIndex);
+                    return [4 /*yield*/, ethersSigner.signMessage(ethers.utils.arrayify(resultHash))];
+                case 2:
+                    signature = _b.sent();
+                    signatures.push(signature);
+                    _b.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    signaturesBytes = ethers.utils.hexConcat(signatures);
+                    return [2 /*return*/, { members: members, signingMembersIndices: signingMembersIndices, signaturesBytes: signaturesBytes }];
+            }
+        });
+    });
+}
+exports.signDkgResult = signDkgResult;
+// Creates a members hash that actively participated in dkg
+function hashDKGMembers(hre, members, misbehavedMembersIndices) {
+    var ethers = hre.ethers;
+    if (misbehavedMembersIndices.length > 0) {
+        var activeDkgMembers = __spreadArray([], __read(members), false);
+        for (var i = 0; i < misbehavedMembersIndices.length; i++) {
+            if (misbehavedMembersIndices[i] !== 0) {
+                activeDkgMembers.splice(misbehavedMembersIndices[i] - i - 1, 1);
+            }
+        }
+        return ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["uint32[]"], [activeDkgMembers]));
+    }
+    return ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["uint32[]"], [members]));
+}
+exports.hashDKGMembers = hashDKGMembers;