@keep-network/tbtc-v2 0.1.0 → 0.1.1-dev

package/export/test/fixtures/bridge.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const smock_1 = require("@defi-wonderland/smock");
+/**
+ * Common fixture for tests suites targeting the Bridge contract.
+ */
+async function bridgeFixture() {
+    await hardhat_1.deployments.fixture();
+    const { deployer, governance, treasury } = await hardhat_1.helpers.signers.getNamedSigners();
+    const [thirdParty] = await hardhat_1.helpers.signers.getUnnamedSigners();
+    const tbtc = await hardhat_1.helpers.contracts.getContract("TBTC");
+    const vendingMachine = await hardhat_1.helpers.contracts.getContract("VendingMachine");
+    const tbtcVault = await hardhat_1.helpers.contracts.getContract("TBTCVault");
+    const bank = await hardhat_1.helpers.contracts.getContract("Bank");
+    const bridge = await hardhat_1.helpers.contracts.getContract("Bridge");
+    const walletRegistry = await smock_1.smock.fake("IWalletRegistry", {
+        address: await (await bridge.contractReferences()).ecdsaWalletRegistry,
+    });
+    // Fund the `walletRegistry` account so it's possible to mock sending requests
+    // from it.
+    await deployer.sendTransaction({
+        to: walletRegistry.address,
+        value: hardhat_1.ethers.utils.parseEther("1"),
+    });
+    const relay = await smock_1.smock.fake("TestRelay", {
+        address: await (await bridge.contractReferences()).relay,
+    });
+    await bank.connect(governance).updateBridge(bridge.address);
+    const BridgeFactory = await hardhat_1.ethers.getContractFactory("BridgeStub", {
+        libraries: {
+            Deposit: (await hardhat_1.helpers.contracts.getContract("Deposit")).address,
+            DepositSweep: (await hardhat_1.helpers.contracts.getContract("DepositSweep")).address,
+            Redemption: (await hardhat_1.helpers.contracts.getContract("Redemption")).address,
+            Wallets: (await hardhat_1.helpers.contracts.getContract("Wallets")).address,
+            Fraud: (await hardhat_1.helpers.contracts.getContract("Fraud")).address,
+            MovingFunds: (await hardhat_1.helpers.contracts.getContract("MovingFunds")).address,
+        },
+    });
+    return {
+        governance,
+        thirdParty,
+        treasury,
+        tbtc,
+        vendingMachine,
+        tbtcVault,
+        bank,
+        relay,
+        walletRegistry,
+        bridge,
+        BridgeFactory,
+    };
+}
+exports.default = bridgeFixture;

package/export/test/fixtures/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movedFundsSweepRequestState = exports.ecdsaDkgState = exports.walletState = exports.constants = void 0;
+const contract_test_helpers_1 = require("../helpers/contract-test-helpers");
+exports.constants = {
+    unmintFee: (0, contract_test_helpers_1.to1ePrecision)(1, 15),
+    depositDustThreshold: 1000000,
+    depositTreasuryFeeDivisor: 2000,
+    depositTxMaxFee: 10000,
+    redemptionDustThreshold: 1000000,
+    redemptionTreasuryFeeDivisor: 2000,
+    redemptionTxMaxFee: 10000,
+    redemptionTimeout: 172800,
+    redemptionTimeoutSlashingAmount: (0, contract_test_helpers_1.to1ePrecision)(10000, 18),
+    redemptionTimeoutNotifierRewardMultiplier: 100,
+    movingFundsTxMaxTotalFee: 10000,
+    movingFundsDustThreshold: 20000,
+    movingFundsTimeoutResetDelay: 518400,
+    movingFundsTimeout: 604800,
+    movingFundsTimeoutSlashingAmount: (0, contract_test_helpers_1.to1ePrecision)(10000, 18),
+    movingFundsTimeoutNotifierRewardMultiplier: 100,
+    movedFundsSweepTxMaxTotalFee: 10000,
+    movedFundsSweepTimeout: 604800,
+    movedFundsSweepTimeoutSlashingAmount: (0, contract_test_helpers_1.to1ePrecision)(10000, 18),
+    movedFundsSweepTimeoutNotifierRewardMultiplier: 100,
+    walletCreationPeriod: 604800,
+    walletCreationMinBtcBalance: (0, contract_test_helpers_1.to1ePrecision)(1, 8),
+    walletCreationMaxBtcBalance: (0, contract_test_helpers_1.to1ePrecision)(100, 8),
+    walletClosureMinBtcBalance: (0, contract_test_helpers_1.to1ePrecision)(5, 7),
+    walletMaxAge: 8 * 604800,
+    walletMaxBtcTransfer: (0, contract_test_helpers_1.to1ePrecision)(10, 8),
+    walletClosingPeriod: 3456000,
+    fraudChallengeDepositAmount: (0, contract_test_helpers_1.to1ePrecision)(2, 18),
+    fraudChallengeDefeatTimeout: 604800,
+    fraudSlashingAmount: (0, contract_test_helpers_1.to1ePrecision)(10000, 18),
+    fraudNotifierRewardMultiplier: 100, // 100%
+};
+exports.walletState = {
+    Unknown: 0,
+    Live: 1,
+    MovingFunds: 2,
+    Closing: 3,
+    Closed: 4,
+    Terminated: 5,
+};
+exports.ecdsaDkgState = {
+    IDLE: 0,
+    AWAITING_SEED: 1,
+    AWAITING_RESULT: 2,
+    CHALLENGE: 3,
+};
+exports.movedFundsSweepRequestState = {
+    Unknown: 0,
+    Pending: 1,
+    Processed: 2,
+    TimedOut: 3,
+};

package/export/test/helpers/contract-test-helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockTime = exports.to1e18 = exports.to1ePrecision = void 0;
+const hardhat_1 = require("hardhat");
+function to1ePrecision(n, precision) {
+    const decimalMultiplier = hardhat_1.ethers.BigNumber.from(10).pow(precision);
+    return hardhat_1.ethers.BigNumber.from(n).mul(decimalMultiplier);
+}
+exports.to1ePrecision = to1ePrecision;
+function to1e18(n) {
+    const decimalMultiplier = hardhat_1.ethers.BigNumber.from(10).pow(18);
+    return hardhat_1.ethers.BigNumber.from(n).mul(decimalMultiplier);
+}
+exports.to1e18 = to1e18;
+async function getBlockTime(blockNumber) {
+    return (await hardhat_1.ethers.provider.getBlock(blockNumber)).timestamp;
+}
+exports.getBlockTime = getBlockTime;

package/export/test/integration/Slashing.test.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @typescript-eslint/no-extra-semi */
+const hardhat_1 = require("hardhat");
+const chai_1 = require("chai");
+const ecdsa_wallet_registry_1 = require("./utils/ecdsa-wallet-registry");
+const random_beacon_1 = require("./utils/random-beacon");
+const gas_1 = require("./utils/gas");
+const fixture_1 = require("./utils/fixture");
+const fraud_1 = require("../data/fraud");
+const fixtures_1 = require("../fixtures");
+const deposit_sweep_1 = require("../data/deposit-sweep");
+const { increaseTime } = hardhat_1.helpers.time;
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const describeFn = process.env.NODE_ENV === "integration-test" ? describe : describe.skip;
+describeFn("Integration Test - Slashing", async () => {
+    let tbtc;
+    let bridge;
+    let tbtcVault;
+    let staking;
+    let walletRegistry;
+    let randomBeacon;
+    let relay;
+    let deployer;
+    let governance;
+    let thirdParty;
+    const dkgResultChallengePeriodLength = 10;
+    before(async () => {
+        ;
+        ({
+            deployer,
+            governance,
+            tbtc,
+            bridge,
+            tbtcVault,
+            staking,
+            walletRegistry,
+            relay,
+            randomBeacon,
+        } = await hardhat_1.waffle.loadFixture(fixture_1.fixture));
+        [thirdParty] = await hardhat_1.helpers.signers.getUnnamedSigners();
+        // Update only the parameters that are crucial for this test.
+        await (0, ecdsa_wallet_registry_1.updateWalletRegistryDkgResultChallengePeriodLength)(walletRegistry, governance, dkgResultChallengePeriodLength);
+    });
+    describe("notifyFraudChallengeDefeatTimeout", async () => {
+        before(async () => {
+            await createSnapshot();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        describe("when wallet is created", async () => {
+            const { publicKey: walletPublicKey, ecdsaWalletID, pubKeyHash160: walletPubKeyHash160, } = fraud_1.wallet;
+            let walletMembers;
+            before("create a wallet", async () => {
+                (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal(hardhat_1.ethers.constants.AddressZero);
+                const requestNewWalletTx = await bridge.requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO);
+                await (0, random_beacon_1.produceRelayEntry)(walletRegistry, randomBeacon);
+                ({ walletMembers } = await (0, ecdsa_wallet_registry_1.performEcdsaDkg)(walletRegistry, walletPublicKey, requestNewWalletTx.blockNumber));
+            });
+            describe("when a fraud is reported", async () => {
+                const fraudulentBtcTx = fraud_1.nonWitnessSignSingleInputTx;
+                let notifyFraudChallengeDefeatTimeoutTx;
+                before(async () => {
+                    const { fraudChallengeDepositAmount, fraudChallengeDefeatTimeout } = await bridge.fraudParameters();
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, fraudulentBtcTx.preimageSha256, fraudulentBtcTx.signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await increaseTime(fraudChallengeDefeatTimeout);
+                    notifyFraudChallengeDefeatTimeoutTx = await bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, walletMembers.getIds(), fraudulentBtcTx.preimageSha256);
+                });
+                it("should slash wallet members", async () => {
+                    const { fraudSlashingAmount: amountToSlash } = await bridge.fraudParameters();
+                    (0, chai_1.expect)(await staking.getSlashingQueueLength()).to.equal(walletMembers.length);
+                    for (let i = 0; i < walletMembers.length; i++) {
+                        const slashing = await staking.slashingQueue(i);
+                        (0, chai_1.expect)(slashing.amount).to.equal(amountToSlash, `unexpected slashing amount for ${i}`);
+                        (0, chai_1.expect)(slashing.stakingProvider).to.equal(walletMembers[i].stakingProvider, `unexpected staking provider for ${i}`);
+                    }
+                });
+                it("should close the wallet in the wallet registry", async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                    (0, chai_1.expect)(await walletRegistry.isWalletRegistered(ecdsaWalletID)).to.be
+                        .false;
+                });
+                it("should terminate the wallet in the bridge", async () => {
+                    const storedWallet = await bridge.wallets(walletPubKeyHash160);
+                    (0, chai_1.expect)(storedWallet.state).to.be.equal(fixtures_1.walletState.Terminated);
+                });
+                it("should consume around 3 100 000 gas for Bridge.notifyMovingFundsTimeoutTx transaction", async () => {
+                    await (0, gas_1.assertGasUsed)(notifyFraudChallengeDefeatTimeoutTx, 3150000, 100000);
+                });
+            });
+        });
+    });
+    describe("notifyRedemptionTimeout", async () => {
+        before(async () => {
+            await createSnapshot();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        describe("when wallet is created", async () => {
+            const deposit = deposit_sweep_1.SingleP2SHDeposit.deposits[0];
+            const { walletPubKeyHash: walletPubKeyHash160 } = deposit.reveal;
+            const { walletPublicKey, walletID: ecdsaWalletID } = deposit.ecdsaWallet;
+            let walletMembers;
+            let redeemerOutputScript;
+            before(async () => {
+                const requestNewWalletTx = await bridge.requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO);
+                await (0, random_beacon_1.produceRelayEntry)(walletRegistry, randomBeacon);
+                ({ walletMembers } = await (0, ecdsa_wallet_registry_1.performEcdsaDkg)(walletRegistry, walletPublicKey, requestNewWalletTx.blockNumber));
+                const { fundingTx, reveal } = deposit_sweep_1.SingleP2SHDeposit.deposits[0];
+                reveal.vault = tbtcVault.address;
+                // We use a deposit funding bitcoin transaction with a very low amount,
+                // so we need to update the dust and redemption thresholds to be below it.
+                await updateDepositDustThreshold(10000); // 0.0001 BTC
+                await updateRedemptionDustThreshold(2000); // 0.00002 BTC
+                // Reveal and sweep the deposit to set up a positive Bank balance for
+                // the redeemer, to be able to request a redemption.
+                await bridge.revealDeposit(fundingTx, reveal);
+                relay.getCurrentEpochDifficulty.returns(deposit_sweep_1.SingleP2SHDeposit.chainDifficulty);
+                relay.getPrevEpochDifficulty.returns(deposit_sweep_1.SingleP2SHDeposit.chainDifficulty);
+                await bridge.submitDepositSweepProof(deposit_sweep_1.SingleP2SHDeposit.sweepTx, deposit_sweep_1.SingleP2SHDeposit.sweepProof, deposit_sweep_1.SingleP2SHDeposit.mainUtxo, tbtcVault.address);
+                const newMainUtxo = {
+                    txHash: deposit_sweep_1.SingleP2SHDeposit.sweepTx.hash,
+                    txOutputIndex: 0,
+                    txOutputValue: 18500, // Value obtained from SingleP2SHDeposit.sweepTx.outputVector
+                };
+                // Request redemption
+                const redeemer = await hardhat_1.helpers.account.impersonateAccount(deposit.reveal.depositor, { from: deployer });
+                const redemptionAmount = 3000;
+                redeemerOutputScript =
+                    "0x17a91486884e6be1525dab5ae0b451bd2c72cee67dcf4187";
+                // Request redemption via TBTC Vault.
+                await tbtc
+                    .connect(redeemer)
+                    .approveAndCall(tbtcVault.address, redemptionAmount, hardhat_1.ethers.utils.defaultAbiCoder.encode(["address", "bytes20", "bytes32", "uint32", "uint64", "bytes"], [
+                    redeemer.address,
+                    walletPubKeyHash160,
+                    newMainUtxo.txHash,
+                    newMainUtxo.txOutputIndex,
+                    newMainUtxo.txOutputValue,
+                    redeemerOutputScript,
+                ]));
+                // Confirm the wallet is still in Live state.
+                (0, chai_1.expect)((await await bridge.wallets(walletPubKeyHash160)).state).to.be.equal(fixtures_1.walletState.Live);
+            });
+            describe("when a redemption timeout is reported", async () => {
+                let notifyRedemptionTimeoutTx;
+                before(async () => {
+                    const { redemptionTimeout } = await bridge.redemptionParameters();
+                    await hardhat_1.helpers.time.increaseTime(redemptionTimeout);
+                    notifyRedemptionTimeoutTx = await bridge
+                        .connect(thirdParty)
+                        .notifyRedemptionTimeout(walletPubKeyHash160, walletMembers.getIds(), redeemerOutputScript);
+                });
+                it("should slash wallet members", async () => {
+                    const { redemptionTimeoutSlashingAmount: amountToSlash } = await bridge.redemptionParameters();
+                    (0, chai_1.expect)(await staking.getSlashingQueueLength()).to.equal(walletMembers.length);
+                    for (let i = 0; i < walletMembers.length; i++) {
+                        const slashing = await staking.slashingQueue(i);
+                        (0, chai_1.expect)(slashing.amount).to.equal(amountToSlash, `unexpected slashing amount for ${i}`);
+                        (0, chai_1.expect)(slashing.stakingProvider).to.equal(walletMembers[i].stakingProvider, `unexpected staking provider for ${i}`);
+                    }
+                });
+                it("should not close the wallet in the wallet registry", async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                    (0, chai_1.expect)(await walletRegistry.isWalletRegistered(ecdsaWalletID)).to.be
+                        .true;
+                });
+                // Since the wallet's balance was above 0, it switched to MovingFunds state.
+                it("should transition the wallet in the bridge to the MovingFunds state", async () => {
+                    const storedWallet = await bridge.wallets(walletPubKeyHash160);
+                    (0, chai_1.expect)(storedWallet.state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                });
+                it("should consume around 3 150 000 gas for Bridge.notifyRedemptionTimeout transaction", async () => {
+                    await (0, gas_1.assertGasUsed)(notifyRedemptionTimeoutTx, 3150000, 100000);
+                });
+            });
+        });
+    });
+    describe("notifyMovingFundsTimeout", async () => {
+        before(async () => {
+            await createSnapshot();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        describe("when wallet is created", async () => {
+            const deposit = deposit_sweep_1.SingleP2SHDeposit.deposits[0];
+            const walletPubKeyHash160 = deposit.reveal.walletPubKeyHash;
+            const { walletPublicKey, walletID: ecdsaWalletID } = deposit.ecdsaWallet;
+            let walletMembers;
+            before(async () => {
+                const requestNewWalletTx = await bridge.requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO);
+                await (0, random_beacon_1.produceRelayEntry)(walletRegistry, randomBeacon);
+                ({ walletMembers } = await (0, ecdsa_wallet_registry_1.performEcdsaDkg)(walletRegistry, walletPublicKey, requestNewWalletTx.blockNumber));
+                const { fundingTx, reveal } = deposit_sweep_1.SingleP2SHDeposit.deposits[0];
+                reveal.vault = tbtcVault.address;
+                // We use a deposit funding bitcoin transaction with a very low amount,
+                // so we need to update the dust threshold to be below it.
+                await updateDepositDustThreshold(10000); // 0.0001 BTC)
+                // Reveal and sweep the deposit to set up a main UTXO for the wallet,
+                // so when operator inactivity is reported the wallet is transferred to
+                // the MovingFunds instead of the Closing state.
+                await bridge.revealDeposit(fundingTx, reveal);
+                relay.getCurrentEpochDifficulty.returns(deposit_sweep_1.SingleP2SHDeposit.chainDifficulty);
+                relay.getPrevEpochDifficulty.returns(deposit_sweep_1.SingleP2SHDeposit.chainDifficulty);
+                await bridge.submitDepositSweepProof(deposit_sweep_1.SingleP2SHDeposit.sweepTx, deposit_sweep_1.SingleP2SHDeposit.sweepProof, deposit_sweep_1.SingleP2SHDeposit.mainUtxo, tbtcVault.address);
+                // Switch the wallet to moving funds state by reporting wallet members
+                // inactivity.
+                const nonce = 0;
+                const walletMembersIDs = walletMembers.getIds();
+                const inactiveMembersIndices = [26, 40, 63, 78, 89];
+                const claim = await (0, ecdsa_wallet_registry_1.produceOperatorInactivityClaim)(ecdsaWalletID, walletMembers, nonce, walletPublicKey, true, inactiveMembersIndices, walletMembers.length / 2 + 1);
+                await walletRegistry
+                    .connect(walletMembers[0].signer)
+                    .notifyOperatorInactivity(claim, nonce, walletMembersIDs);
+            });
+            describe("when moving funds timeout is reported", async () => {
+                let notifyMovingFundsTimeoutTx;
+                before(async () => {
+                    (0, chai_1.expect)(await (await bridge.wallets(walletPubKeyHash160)).state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                    const { movingFundsTimeout } = await bridge.movingFundsParameters();
+                    await hardhat_1.helpers.time.increaseTime(movingFundsTimeout);
+                    notifyMovingFundsTimeoutTx = await bridge
+                        .connect(thirdParty)
+                        .notifyMovingFundsTimeout(walletPubKeyHash160, walletMembers.getIds());
+                });
+                it("should slash wallet members", async () => {
+                    const { movingFundsTimeoutSlashingAmount: amountToSlash } = await bridge.movingFundsParameters();
+                    (0, chai_1.expect)(await staking.getSlashingQueueLength()).to.equal(walletMembers.length);
+                    for (let i = 0; i < walletMembers.length; i++) {
+                        const slashing = await staking.slashingQueue(i);
+                        (0, chai_1.expect)(slashing.amount).to.equal(amountToSlash, `unexpected slashing amount for ${i}`);
+                        (0, chai_1.expect)(slashing.stakingProvider).to.equal(walletMembers[i].stakingProvider, `unexpected staking provider for ${i}`);
+                    }
+                });
+                it("should close the wallet in the wallet registry", async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                    (0, chai_1.expect)(await walletRegistry.isWalletRegistered(ecdsaWalletID)).to.be
+                        .false;
+                });
+                it("should terminate the wallet in the bridge", async () => {
+                    const storedWallet = await bridge.wallets(walletPubKeyHash160);
+                    (0, chai_1.expect)(storedWallet.state).to.be.equal(fixtures_1.walletState.Terminated);
+                });
+                it("should consume around 3 100 000 gas for Bridge.notifyMovingFundsTimeoutTx transaction", async () => {
+                    await (0, gas_1.assertGasUsed)(notifyMovingFundsTimeoutTx, 3100000, 50000);
+                });
+            });
+        });
+    });
+    async function updateDepositDustThreshold(newDepositDustThreshold) {
+        const currentDepositParameters = await bridge.depositParameters();
+        await bridge
+            .connect(governance)
+            .updateDepositParameters(newDepositDustThreshold, currentDepositParameters.depositTreasuryFeeDivisor, currentDepositParameters.depositTxMaxFee);
+    }
+    async function updateRedemptionDustThreshold(newRedemptionDustThreshold) {
+        // Redemption dust threshold has to be greater than moving funds dust threshold,
+        // so first we need to align the moving funds dust threshold.
+        const newMovingFundsDustThreshold = newRedemptionDustThreshold - 1;
+        const currentMovingFundsParameters = await bridge.movingFundsParameters();
+        await bridge
+            .connect(governance)
+            .updateMovingFundsParameters(currentMovingFundsParameters.movingFundsTxMaxTotalFee, newMovingFundsDustThreshold, currentMovingFundsParameters.movingFundsTimeoutResetDelay, currentMovingFundsParameters.movingFundsTimeout, currentMovingFundsParameters.movingFundsTimeoutSlashingAmount, currentMovingFundsParameters.movingFundsTimeoutNotifierRewardMultiplier, currentMovingFundsParameters.movedFundsSweepTxMaxTotalFee, currentMovingFundsParameters.movedFundsSweepTimeout, currentMovingFundsParameters.movedFundsSweepTimeoutSlashingAmount, currentMovingFundsParameters.movedFundsSweepTimeoutNotifierRewardMultiplier);
+        const currentRedemptionParameters = await bridge.redemptionParameters();
+        await bridge
+            .connect(governance)
+            .updateRedemptionParameters(newRedemptionDustThreshold, currentRedemptionParameters.redemptionTreasuryFeeDivisor, currentRedemptionParameters.redemptionTxMaxFee, currentRedemptionParameters.redemptionTimeout, currentRedemptionParameters.redemptionTimeoutSlashingAmount, currentRedemptionParameters.redemptionTimeoutNotifierRewardMultiplier);
+    }
+});

package/export/test/integration/WalleCreation.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-extra-semi */
+const hardhat_1 = require("hardhat");
+const chai_1 = require("chai");
+const ecdsa_wallet_registry_1 = require("./utils/ecdsa-wallet-registry");
+const ecdsa_1 = require("../data/ecdsa");
+const random_beacon_1 = require("./utils/random-beacon");
+const gas_1 = require("./utils/gas");
+const fixture_1 = require("./utils/fixture");
+const fixtures_1 = require("../fixtures");
+const NO_MAIN_UTXO = {
+    txHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    txOutputIndex: 0,
+    txOutputValue: 0,
+};
+const describeFn = process.env.NODE_ENV === "integration-test" ? describe : describe.skip;
+describeFn("Integration Test - Wallet Creation", async () => {
+    let bridge;
+    let walletRegistry;
+    let randomBeacon;
+    let governance;
+    const dkgResultChallengePeriodLength = 10;
+    // TODO: Generate a random public key
+    const walletPublicKey = ecdsa_1.ecdsaWalletTestData.publicKey;
+    const { walletID } = ecdsa_1.ecdsaWalletTestData;
+    const walletPubKeyHash = ecdsa_1.ecdsaWalletTestData.pubKeyHash160;
+    before(async () => {
+        ;
+        ({ governance, bridge, walletRegistry, randomBeacon } =
+            await hardhat_1.waffle.loadFixture(fixture_1.fixture));
+        // Update only the parameters that are crucial for this test.
+        await (0, ecdsa_wallet_registry_1.updateWalletRegistryDkgResultChallengePeriodLength)(walletRegistry, governance, dkgResultChallengePeriodLength);
+    });
+    describe("new wallet creation (happy path)", async () => {
+        let requestNewWalletTx;
+        let walletRegistrationTx;
+        before(async () => {
+            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal(hardhat_1.ethers.constants.AddressZero);
+            requestNewWalletTx = await bridge.requestNewWallet(NO_MAIN_UTXO);
+            const startBlock = requestNewWalletTx.blockNumber;
+            await (0, random_beacon_1.produceRelayEntry)(walletRegistry, randomBeacon);
+            ({ approveDkgResultTx: walletRegistrationTx } = await (0, ecdsa_wallet_registry_1.performEcdsaDkg)(walletRegistry, walletPublicKey, startBlock));
+            await walletRegistrationTx.wait();
+        });
+        it("should register a new wallet in the WalletRegistry", async () => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            (0, chai_1.expect)(await walletRegistry.isWalletRegistered(walletID)).to.be.true;
+        });
+        it("should register a new wallet details in the Bridge", async () => {
+            const storedWallet = await bridge.wallets(walletPubKeyHash);
+            (0, chai_1.expect)(storedWallet.ecdsaWalletID).to.be.equal(ecdsa_1.ecdsaWalletTestData.walletID);
+            (0, chai_1.expect)(storedWallet.state).to.be.equal(fixtures_1.walletState.Live);
+            (0, chai_1.expect)(storedWallet.createdAt).to.be.equal((await hardhat_1.ethers.provider.getBlock((await walletRegistrationTx.wait()).blockNumber)).timestamp);
+        });
+        it("should register a new wallet as active in the Bridge", async () => {
+            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal(walletPubKeyHash);
+        });
+        it("should consume around 93 000 gas for Bridge.requestNewWallet transaction", async () => {
+            await (0, gas_1.assertGasUsed)(requestNewWalletTx, 93000);
+        });
+        it("should consume around 339 000 gas for WalletRegistry.approveDkgResult transaction", async () => {
+            await (0, gas_1.assertGasUsed)(walletRegistrationTx, 339000);
+        });
+    });
+});

package/export/test/integration/utils/ecdsa-wallet-registry.js

@@ -0,0 +1,137 @@
+"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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operators = exports.produceOperatorInactivityClaim = exports.updateWalletRegistryDkgResultChallengePeriodLength = exports.performEcdsaDkg = exports.registerOperator = void 0;
+/* eslint-disable no-await-in-loop */
+const hardhat_1 = require("hardhat");
+async function registerOperator(walletRegistry, sortitionPool, stakingProvider, operator) {
+    await walletRegistry
+        .connect(stakingProvider)
+        .registerOperator(await operator.getAddress());
+    await walletRegistry.connect(operator).joinSortitionPool();
+    const operatorID = await sortitionPool.getOperatorID(await operator.getAddress());
+    return operatorID;
+}
+exports.registerOperator = registerOperator;
+async function performEcdsaDkg(walletRegistry, groupPublicKey, startBlock) {
+    const { signers: walletMembers, dkgResult, submitter, submitDkgResultTx: dkgResultSubmissionTx, } = await signAndSubmitDkgResult(walletRegistry, groupPublicKey, startBlock);
+    await hardhat_1.helpers.time.mineBlocksTo(dkgResultSubmissionTx.blockNumber +
+        (await walletRegistry.dkgParameters()).resultChallengePeriodLength.toNumber());
+    const approveDkgResultTx = await walletRegistry
+        .connect(submitter)
+        .approveDkgResult(dkgResult);
+    return { approveDkgResultTx, walletMembers };
+}
+exports.performEcdsaDkg = performEcdsaDkg;
+async function updateWalletRegistryDkgResultChallengePeriodLength(walletRegistry, governance, dkgResultChallengePeriodLength) {
+    const walletRegistryGovernance = await hardhat_1.ethers.getContractAt((await hardhat_1.deployments.getArtifact("WalletRegistryGovernance")).abi, await walletRegistry.governance());
+    await walletRegistryGovernance
+        .connect(governance)
+        .beginDkgResultChallengePeriodLengthUpdate(dkgResultChallengePeriodLength);
+    await hardhat_1.helpers.time.increaseTime(await walletRegistryGovernance.governanceDelay());
+    await walletRegistryGovernance
+        .connect(governance)
+        .finalizeDkgResultChallengePeriodLengthUpdate();
+}
+exports.updateWalletRegistryDkgResultChallengePeriodLength = updateWalletRegistryDkgResultChallengePeriodLength;
+async function selectGroup(walletRegistry) {
+    const sortitionPool = (await hardhat_1.ethers.getContractAt("SortitionPool", await walletRegistry.sortitionPool()));
+    const identifiers = await walletRegistry.selectGroup();
+    const addresses = await sortitionPool.getIDOperators(identifiers);
+    return new Operators(...(await Promise.all(identifiers.map(async (identifier, i) => ({
+        id: identifier,
+        signer: await hardhat_1.ethers.getSigner(addresses[i]),
+        stakingProvider: await walletRegistry.operatorToStakingProvider(addresses[i]),
+    })))));
+}
+async function produceOperatorInactivityClaim(walletID, signers, nonce, groupPubKey, heartbeatFailed, inactiveMembersIndices, numberOfSignatures) {
+    const messageHash = hardhat_1.ethers.utils.solidityKeccak256(["uint256", "bytes", "uint8[]", "bool"], [nonce, groupPubKey, inactiveMembersIndices, heartbeatFailed]);
+    const signingMembersIndices = [];
+    const signatures = [];
+    for (let i = 0; i < signers.length; i++) {
+        if (signatures.length === numberOfSignatures) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const signerIndex = i + 1;
+        signingMembersIndices.push(signerIndex);
+        const signature = await signers[i].signer.signMessage(hardhat_1.ethers.utils.arrayify(messageHash));
+        signatures.push(signature);
+    }
+    return {
+        walletID,
+        inactiveMembersIndices,
+        heartbeatFailed,
+        signatures: hardhat_1.ethers.utils.hexConcat(signatures),
+        signingMembersIndices,
+    };
+}
+exports.produceOperatorInactivityClaim = produceOperatorInactivityClaim;
+class Operators extends Array {
+    getIds() {
+        return this.map((operator) => operator.id);
+    }
+    getSigners() {
+        return this.map((operator) => operator.signer);
+    }
+}
+exports.Operators = Operators;
+const noMisbehaved = [];
+async function signAndSubmitDkgResult(walletRegistry, groupPublicKey, startBlock, misbehavedIndices = noMisbehaved) {
+    const signers = await selectGroup(walletRegistry);
+    const submitterIndex = 1;
+    const { dkgResult } = await signDkgResult(signers, groupPublicKey, misbehavedIndices, startBlock, submitterIndex);
+    const submitter = signers[submitterIndex - 1].signer;
+    const submitDkgResultTx = await walletRegistry
+        .connect(submitter)
+        .submitDkgResult(dkgResult);
+    return {
+        signers,
+        dkgResult,
+        submitter,
+        submitDkgResultTx,
+    };
+}
+async function signDkgResult(signers, groupPublicKey, misbehavedMembersIndices, startBlock, submitterIndex) {
+    const numberOfSignatures = signers.length / 2 + 1;
+    const resultHash = hardhat_1.ethers.utils.solidityKeccak256(["bytes", "uint8[]", "uint256"], [groupPublicKey, misbehavedMembersIndices, startBlock]);
+    const members = [];
+    const signingMembersIndices = [];
+    const signatures = [];
+    for (let i = 0; i < signers.length; i++) {
+        const { id, signer: ethersSigner } = signers[i];
+        members.push(id);
+        if (signatures.length === numberOfSignatures) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const signerIndex = i + 1;
+        signingMembersIndices.push(signerIndex);
+        const signature = await ethersSigner.signMessage(hardhat_1.ethers.utils.arrayify(resultHash));
+        signatures.push(signature);
+    }
+    const signaturesBytes = hardhat_1.ethers.utils.hexConcat(signatures);
+    const dkgResult = {
+        submitterMemberIndex: submitterIndex,
+        groupPubKey: groupPublicKey,
+        misbehavedMembersIndices,
+        signatures: signaturesBytes,
+        signingMembersIndices,
+        members,
+        membersHash: hashDKGMembers(members, misbehavedMembersIndices),
+    };
+    return { dkgResult, signingMembersIndices, signaturesBytes };
+}
+function hashDKGMembers(members, misbehavedMembersIndices) {
+    if (misbehavedMembersIndices && misbehavedMembersIndices.length > 0) {
+        const activeDkgMembers = [...members];
+        for (let i = 0; i < misbehavedMembersIndices.length; i++) {
+            if (misbehavedMembersIndices[i] !== 0) {
+                activeDkgMembers.splice(misbehavedMembersIndices[i] - i - 1, 1);
+            }
+        }
+        return hardhat_1.ethers.utils.keccak256(hardhat_1.ethers.utils.defaultAbiCoder.encode(["uint32[]"], [activeDkgMembers]));
+    }
+    return hardhat_1.ethers.utils.keccak256(hardhat_1.ethers.utils.defaultAbiCoder.encode(["uint32[]"], [members]));
+}