@keep-network/tbtc-v2 1.2.0-dev.1 → 1.2.0

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

@@ -1,12 +0,0 @@
-"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

@@ -1,133 +0,0 @@
-"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

@@ -1,370 +0,0 @@
-"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]));
-}