@keep-network/tbtc-v2 1.5.0 → 1.5.1

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/ecdsa-wallet-registry.js

@@ -0,0 +1,370 @@
+"use strict";
+// TODO: Utils in this file are pulled from @keep-network/ecdsa test utils.
+// We should consider exposing them in @keep-network/ecdsa for an external usage.
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.Operators = exports.produceOperatorInactivityClaim = exports.updateWalletRegistryDkgResultChallengePeriodLength = exports.performEcdsaDkg = exports.registerOperator = exports.hardhatNetworkId = void 0;
+// default Hardhat's networks blockchain, see https://hardhat.org/config/
+exports.hardhatNetworkId = 31337;
+function registerOperator(walletRegistry, sortitionPool, stakingProvider, operator) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, _b, operatorID, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _b = (_a = walletRegistry
+                        .connect(stakingProvider))
+                        .registerOperator;
+                    return [4 /*yield*/, operator.getAddress()];
+                case 1: return [4 /*yield*/, _b.apply(_a, [_e.sent()])];
+                case 2:
+                    _e.sent();
+                    return [4 /*yield*/, walletRegistry.connect(operator).joinSortitionPool()];
+                case 3:
+                    _e.sent();
+                    _d = (_c = sortitionPool).getOperatorID;
+                    return [4 /*yield*/, operator.getAddress()];
+                case 4: return [4 /*yield*/, _d.apply(_c, [_e.sent()])];
+                case 5:
+                    operatorID = _e.sent();
+                    return [2 /*return*/, operatorID];
+            }
+        });
+    });
+}
+exports.registerOperator = registerOperator;
+function performEcdsaDkg(hre, walletRegistry, groupPublicKey, startBlock) {
+    return __awaiter(this, void 0, void 0, function () {
+        var helpers, _a, walletMembers, dkgResult, submitter, dkgResultSubmissionTx, _b, _c, _d, approveDkgResultTx;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    helpers = hre.helpers;
+                    return [4 /*yield*/, signAndSubmitDkgResult(hre, walletRegistry, groupPublicKey, startBlock)];
+                case 1:
+                    _a = _e.sent(), walletMembers = _a.signers, dkgResult = _a.dkgResult, submitter = _a.submitter, dkgResultSubmissionTx = _a.submitDkgResultTx;
+                    _c = (_b = helpers.time).mineBlocksTo;
+                    _d = dkgResultSubmissionTx.blockNumber;
+                    return [4 /*yield*/, walletRegistry.dkgParameters()];
+                case 2: return [4 /*yield*/, _c.apply(_b, [_d +
+                            (_e.sent()).resultChallengePeriodLength.toNumber()])];
+                case 3:
+                    _e.sent();
+                    return [4 /*yield*/, walletRegistry
+                            .connect(submitter)
+                            .approveDkgResult(dkgResult)];
+                case 4:
+                    approveDkgResultTx = _e.sent();
+                    return [2 /*return*/, { approveDkgResultTx: approveDkgResultTx, walletMembers: walletMembers }];
+            }
+        });
+    });
+}
+exports.performEcdsaDkg = performEcdsaDkg;
+function updateWalletRegistryDkgResultChallengePeriodLength(hre, walletRegistry, governance, dkgResultChallengePeriodLength) {
+    return __awaiter(this, void 0, void 0, function () {
+        var deployments, ethers, helpers, walletRegistryGovernance, _a, _b, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    deployments = hre.deployments, ethers = hre.ethers, helpers = hre.helpers;
+                    _b = (_a = ethers).getContractAt;
+                    return [4 /*yield*/, deployments.getArtifact("WalletRegistryGovernance")];
+                case 1:
+                    _c = [(_f.sent()).abi];
+                    return [4 /*yield*/, walletRegistry.governance()];
+                case 2: return [4 /*yield*/, _b.apply(_a, _c.concat([_f.sent()]))];
+                case 3:
+                    walletRegistryGovernance = _f.sent();
+                    return [4 /*yield*/, walletRegistryGovernance
+                            .connect(governance)
+                            .beginDkgResultChallengePeriodLengthUpdate(dkgResultChallengePeriodLength)];
+                case 4:
+                    _f.sent();
+                    _e = (_d = helpers.time).increaseTime;
+                    return [4 /*yield*/, walletRegistryGovernance.governanceDelay()];
+                case 5: return [4 /*yield*/, _e.apply(_d, [_f.sent()])];
+                case 6:
+                    _f.sent();
+                    return [4 /*yield*/, walletRegistryGovernance
+                            .connect(governance)
+                            .finalizeDkgResultChallengePeriodLengthUpdate()];
+                case 7:
+                    _f.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.updateWalletRegistryDkgResultChallengePeriodLength = updateWalletRegistryDkgResultChallengePeriodLength;
+function selectGroup(hre, walletRegistry) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers, sortitionPool, _a, _b, _c, identifiers, addresses, _d, _e, _f, _g;
+        var _this = this;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    ethers = hre.ethers;
+                    _b = (_a = ethers).getContractAt;
+                    _c = ["SortitionPool"];
+                    return [4 /*yield*/, walletRegistry.sortitionPool()];
+                case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([_h.sent()]))];
+                case 2:
+                    sortitionPool = (_h.sent());
+                    return [4 /*yield*/, walletRegistry.selectGroup()];
+                case 3:
+                    identifiers = _h.sent();
+                    return [4 /*yield*/, sortitionPool.getIDOperators(identifiers)];
+                case 4:
+                    addresses = _h.sent();
+                    _e = (_d = Operators.bind).apply;
+                    _f = [Operators];
+                    _g = [[void 0]];
+                    return [4 /*yield*/, 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:
+                                        _a.signer = _b.sent();
+                                        return [4 /*yield*/, walletRegistry.operatorToStakingProvider(addresses[i])];
+                                    case 2: return [2 /*return*/, (_a.stakingProvider = _b.sent(),
+                                            _a)];
+                                }
+                            });
+                        }); }))];
+                case 5: return [2 /*return*/, new (_e.apply(_d, _f.concat([__spreadArray.apply(void 0, _g.concat([__read.apply(void 0, [(_h.sent())]), false]))])))()];
+            }
+        });
+    });
+}
+function produceOperatorInactivityClaim(hre, walletID, signers, nonce, groupPubKey, heartbeatFailed, inactiveMembersIndices, numberOfSignatures) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers, messageHash, signingMembersIndices, signatures, i, signerIndex, signature;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ethers = hre.ethers;
+                    messageHash = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["uint256", "uint256", "bytes", "uint8[]", "bool"], [
+                        exports.hardhatNetworkId,
+                        nonce,
+                        groupPubKey,
+                        inactiveMembersIndices,
+                        heartbeatFailed,
+                    ]));
+                    signingMembersIndices = [];
+                    signatures = [];
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < signers.length)) return [3 /*break*/, 4];
+                    if (signatures.length === numberOfSignatures) {
+                        // eslint-disable-next-line no-continue
+                        return [3 /*break*/, 3];
+                    }
+                    signerIndex = i + 1;
+                    signingMembersIndices.push(signerIndex);
+                    return [4 /*yield*/, signers[i].signer.signMessage(ethers.utils.arrayify(messageHash))];
+                case 2:
+                    signature = _a.sent();
+                    signatures.push(signature);
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, {
+                        walletID: walletID,
+                        inactiveMembersIndices: inactiveMembersIndices,
+                        heartbeatFailed: heartbeatFailed,
+                        signatures: ethers.utils.hexConcat(signatures),
+                        signingMembersIndices: signingMembersIndices,
+                    }];
+            }
+        });
+    });
+}
+exports.produceOperatorInactivityClaim = produceOperatorInactivityClaim;
+var Operators = /** @class */ (function (_super) {
+    __extends(Operators, _super);
+    function Operators() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Operators.prototype.getIds = function () {
+        return this.map(function (operator) { return operator.id; });
+    };
+    Operators.prototype.getSigners = function () {
+        return this.map(function (operator) { return operator.signer; });
+    };
+    return Operators;
+}(Array));
+exports.Operators = Operators;
+var noMisbehaved = [];
+function signAndSubmitDkgResult(hre, walletRegistry, groupPublicKey, startBlock, misbehavedIndices) {
+    if (misbehavedIndices === void 0) { misbehavedIndices = noMisbehaved; }
+    return __awaiter(this, void 0, void 0, function () {
+        var signers, submitterIndex, dkgResult, submitter, submitDkgResultTx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, selectGroup(hre, walletRegistry)];
+                case 1:
+                    signers = _a.sent();
+                    submitterIndex = 1;
+                    return [4 /*yield*/, signDkgResult(hre, signers, groupPublicKey, misbehavedIndices, startBlock, submitterIndex)];
+                case 2:
+                    dkgResult = (_a.sent()).dkgResult;
+                    submitter = signers[submitterIndex - 1].signer;
+                    return [4 /*yield*/, walletRegistry
+                            .connect(submitter)
+                            .submitDkgResult(dkgResult)];
+                case 3:
+                    submitDkgResultTx = _a.sent();
+                    return [2 /*return*/, {
+                            signers: signers,
+                            dkgResult: dkgResult,
+                            submitter: submitter,
+                            submitDkgResultTx: submitDkgResultTx,
+                        }];
+            }
+        });
+    });
+}
+function signDkgResult(hre, signers, groupPublicKey, misbehavedMembersIndices, startBlock, submitterIndex) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ethers, numberOfSignatures, resultHash, members, signingMembersIndices, signatures, i, _a, id, ethersSigner, signerIndex, signature, signaturesBytes, dkgResult;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    ethers = hre.ethers;
+                    numberOfSignatures = signers.length / 2 + 1;
+                    resultHash = ethers.utils.keccak256(ethers.utils.defaultAbiCoder.encode(["uint256", "bytes", "uint8[]", "uint256"], [exports.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);
+                    dkgResult = {
+                        submitterMemberIndex: submitterIndex,
+                        groupPubKey: groupPublicKey,
+                        misbehavedMembersIndices: misbehavedMembersIndices,
+                        signatures: signaturesBytes,
+                        signingMembersIndices: signingMembersIndices,
+                        members: members,
+                        membersHash: hashDKGMembers(hre, members, misbehavedMembersIndices),
+                    };
+                    return [2 /*return*/, { dkgResult: dkgResult, signingMembersIndices: signingMembersIndices, signaturesBytes: signaturesBytes }];
+            }
+        });
+    });
+}
+function hashDKGMembers(hre, members, misbehavedMembersIndices) {
+    var ethers = hre.ethers;
+    if (misbehavedMembersIndices && 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]));
+}