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

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keep-network/tbtc-v2",
-  "version": "1.0.0-dev.4+main.fff35b9f4374c6fb28abf679501640c2f14e32bf",
+  "version": "1.0.0-dev.5+main.a2e8a5df0cd75b762f8f5b371e27de976578bc03",
   "license": "GPL-3.0-only",
   "files": [
     "artifacts/",
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@keep-network/bitcoin-spv-sol": "3.4.0-solc-0.8",
-    "@keep-network/ecdsa": "2.1.0-dev.4",
-    "@keep-network/random-beacon": "2.1.0-dev.4",
+    "@keep-network/ecdsa": "2.1.0-dev.5",
+    "@keep-network/random-beacon": "2.1.0-dev.5",
     "@keep-network/tbtc": "1.1.2-dev.1",
     "@openzeppelin/contracts": "^4.6.0",
     "@openzeppelin/contracts-upgradeable": "^4.6.0",

package/tasks/test-utils.ts

@@ -4,16 +4,32 @@
 import { task, types } from "hardhat/config"
 import type { HardhatRuntimeEnvironment } from "hardhat/types"
 import { BigNumberish, BytesLike } from "ethers"
+import type { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"
 import { authorizeApplication, stake } from "../test/integration/utils/staking"
 import {
   performEcdsaDkg,
   registerOperator,
 } from "../test/integration/utils/ecdsa-wallet-registry"
 import type { Bridge, SortitionPool, WalletRegistry } from "../typechain"
+import {
+  offchainDkgTime,
+  dkgResultChallengePeriodLength,
+} from "../test/integration/data/integration"
+import blsData from "../test/integration/data/bls"
+import {
+  updateDkgResultChallengePeriodLength,
+  getGenesisSeed,
+  selectGroup,
+  signDkgResult,
+  hashDKGMembers,
+} from "../test/integration/utils/random-beacon"
+
+export type OperatorID = number
+export type Operator = { id: OperatorID; signer: SignerWithAddress }
 
 task(
   "test-utils:register-operators",
-  "Registers operators in the sortition pool"
+  "Registers operators in the sortition pools"
 )
   .addOptionalParam(
     "numberOfOperators",
@@ -66,15 +82,29 @@ async function registerOperators(
 ): Promise<void> {
   const { helpers } = hre
 
+  const { chaosnetOwner } = await helpers.signers.getNamedSigners()
+
   const walletRegistry = await helpers.contracts.getContract<WalletRegistry>(
     "WalletRegistry"
   )
-  const sortitionPool = await helpers.contracts.getContract<SortitionPool>(
+  const ecdsaSortitionPool = await helpers.contracts.getContract<SortitionPool>(
     "EcdsaSortitionPool"
   )
   const t = await helpers.contracts.getContract("T")
   const staking = await helpers.contracts.getContract("TokenStaking")
 
+  if (await ecdsaSortitionPool.isChaosnetActive()) {
+    await ecdsaSortitionPool.connect(chaosnetOwner).deactivateChaosnet()
+  }
+
+  const randomBeacon = await helpers.contracts.getContract("RandomBeacon")
+  const beaconSortitionPool =
+    await helpers.contracts.getContract<SortitionPool>("BeaconSortitionPool")
+
+  if (await beaconSortitionPool.isChaosnetActive()) {
+    await beaconSortitionPool.connect(chaosnetOwner).deactivateChaosnet()
+  }
+
   const signers = (await helpers.signers.getUnnamedSigners()).slice(
     unnamedSignersOffset
   )
@@ -114,12 +144,24 @@ async function registerOperators(
       stakingProvider.address,
       stakeAmount
     )
+    await authorizeApplication(
+      staking,
+      randomBeacon.address,
+      authorizer,
+      stakingProvider.address,
+      stakeAmount
+    )
     await registerOperator(
       walletRegistry,
-      sortitionPool,
+      ecdsaSortitionPool,
       stakingProvider,
       operator
     )
+    await randomBeacon
+      .connect(stakingProvider)
+      .registerOperator(await operator.getAddress())
+
+    await randomBeacon.connect(operator).joinSortitionPool()
   }
 
   console.log(`Registered ${numberOfOperators} sortition pool operators`)
@@ -128,7 +170,7 @@ async function registerOperators(
 async function createWallet(
   hre: HardhatRuntimeEnvironment,
   walletPublicKey: BytesLike
-) {
+): Promise<void> {
   const { ethers, helpers } = hre
   const { governance } = await helpers.signers.getNamedSigners()
 
@@ -139,6 +181,48 @@ async function createWallet(
   const walletRegistryGovernance = await helpers.contracts.getContract(
     "WalletRegistryGovernance"
   )
+  const randomBeacon = await helpers.contracts.getContract("RandomBeacon")
+  const randomBeaconGovernance = await helpers.contracts.getContract(
+    "RandomBeaconGovernance"
+  )
+
+  await updateDkgResultChallengePeriodLength(
+    hre,
+    governance,
+    randomBeaconGovernance
+  )
+
+  const genesisTx = await randomBeacon.genesis()
+  const genesisBlock = genesisTx.blockNumber
+  const genesisSeed = await getGenesisSeed(hre, genesisBlock)
+
+  await helpers.time.mineBlocksTo(genesisBlock + offchainDkgTime + 1)
+
+  const sortitionPool = await helpers.contracts.getContract<SortitionPool>(
+    "BeaconSortitionPool"
+  )
+
+  const signers = await selectGroup(hre, sortitionPool, genesisSeed)
+  const { members, signingMembersIndices, signaturesBytes } =
+    await signDkgResult(hre, signers, blsData.groupPubKey, [], genesisBlock, 33)
+  const membersHash = hashDKGMembers(hre, members, [])
+
+  const dkgResult = {
+    submitterMemberIndex: 1,
+    groupPubKey: blsData.groupPubKey,
+    misbehavedMembersIndices: [],
+    signatures: signaturesBytes,
+    signingMembersIndices,
+    members,
+    membersHash,
+  }
+
+  const submitter = signers[0].signer
+  await randomBeacon.connect(submitter).submitDkgResult(dkgResult)
+
+  await helpers.time.mineBlocks(dkgResultChallengePeriodLength + 1)
+
+  await randomBeacon.connect(submitter).approveDkgResult(dkgResult)
 
   const requestNewWalletTx = await bridge.requestNewWallet({
     txHash: ethers.constants.HashZero,