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

package/export/test/bridge/Bridge.MovingFunds.test.js

@@ -0,0 +1,2437 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-underscore-dangle */
+const hardhat_1 = require("hardhat");
+const chai_1 = __importStar(require("chai"));
+const smock_1 = require("@defi-wonderland/smock");
+const bridge_1 = __importDefault(require("../fixtures/bridge"));
+const fixtures_1 = require("../fixtures");
+const moving_funds_1 = require("../data/moving-funds");
+const ecdsa_1 = require("../data/ecdsa");
+const deposit_sweep_1 = require("../data/deposit-sweep");
+const contract_test_helpers_1 = require("../helpers/contract-test-helpers");
+chai_1.default.use(smock_1.smock.matchers);
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const { lastBlockTime, increaseTime } = hardhat_1.helpers.time;
+describe("Bridge - Moving funds", () => {
+    let thirdParty;
+    let treasury;
+    let bank;
+    let relay;
+    let walletRegistry;
+    let bridge;
+    let BridgeFactory;
+    let movingFundsTimeoutResetDelay;
+    let movingFundsTimeout;
+    let movingFundsTimeoutSlashingAmount;
+    let movingFundsTimeoutNotifierRewardMultiplier;
+    let movedFundsSweepTimeout;
+    let movedFundsSweepTimeoutSlashingAmount;
+    let movedFundsSweepTimeoutNotifierRewardMultiplier;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({
+            thirdParty,
+            treasury,
+            bank,
+            relay,
+            walletRegistry,
+            bridge,
+            BridgeFactory,
+        } = await hardhat_1.waffle.loadFixture(bridge_1.default));
+        ({
+            movingFundsTimeoutResetDelay,
+            movingFundsTimeout,
+            movingFundsTimeoutSlashingAmount,
+            movingFundsTimeoutNotifierRewardMultiplier,
+            movedFundsSweepTimeout,
+            movedFundsSweepTimeoutSlashingAmount,
+            movedFundsSweepTimeoutNotifierRewardMultiplier,
+        } = await bridge.movingFundsParameters());
+    });
+    describe("submitMovingFundsCommitment", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        context("when source wallet is in the MovingFunds state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.MovingFunds,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when source wallet has no pending redemptions", () => {
+                // The wallet created using the `walletDraft` has no pending redemptions
+                // by default. No need to do anything here.
+                context("when source wallet has no pending moved funds sweep requests", () => {
+                    // The wallet created using the `walletDraft` has no pending moved
+                    // funds sweep requests by default. No need to do anything here.
+                    context("when the commitment was not submitted yet", () => {
+                        // The wallet created using the `walletDraft` has no commitment
+                        // submitted by default. No need to do anything here.
+                        context("when the caller is a member of the source wallet", () => {
+                            const walletMembersIDs = [1, 2, 3, 4, 5];
+                            const walletMemberIndex = 2;
+                            let caller;
+                            before(async () => {
+                                await createSnapshot();
+                                caller = thirdParty;
+                                walletRegistry.isWalletMember
+                                    .whenCalledWith(ecdsa_1.ecdsaWalletTestData.walletID, walletMembersIDs, caller.address, walletMemberIndex)
+                                    .returns(true);
+                            });
+                            after(async () => {
+                                walletRegistry.isWalletMember.reset();
+                                await restoreSnapshot();
+                            });
+                            context("when passed wallet main UTXO is valid", () => {
+                                context("when wallet balance is greater than zero", () => {
+                                    // Just an arbitrary main UTXO with value of 26 BTC.
+                                    const mainUtxo = {
+                                        txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                        txOutputIndex: 0,
+                                        txOutputValue: (0, contract_test_helpers_1.to1ePrecision)(26, 8),
+                                    };
+                                    before(async () => {
+                                        await createSnapshot();
+                                        // Set up a main UTXO for the source wallet.
+                                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                                    });
+                                    after(async () => {
+                                        await restoreSnapshot();
+                                    });
+                                    context("when the expected target wallets count is greater than zero", () => {
+                                        // Just some arbitrary 20-byte hashes to simulate live
+                                        // wallets PKHs. They are ordered in the expected way, i.e.
+                                        // the hashes represented as numbers form a strictly
+                                        // increasing sequence.
+                                        const liveWallets = [
+                                            "0x4b440cb29c80c3f256212d8fdd4f2125366f3c91",
+                                            "0x888f01315e0268bfa05d5e522f8d63f6824d9a96",
+                                            "0xb2a89e53a4227dbe530a52a1c419040735fa636c",
+                                            "0xbf198e8fff0f90af01024153701da99b9bc08dc5",
+                                            "0xffb9e05013f5cd126915bc03d340cc5c1be81862",
+                                        ];
+                                        before(async () => {
+                                            await createSnapshot();
+                                            for (let i = 0; i < liveWallets.length; i++) {
+                                                // eslint-disable-next-line no-await-in-loop
+                                                await bridge.setWallet(liveWallets[i], {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                            }
+                                        });
+                                        after(async () => {
+                                            await restoreSnapshot();
+                                        });
+                                        context("when the submitted target wallets count is same as the expected", () => {
+                                            // The source wallet has a main UTXO with value of 26 BTC,
+                                            // the max BTC transfer is 10 BTC by default (see
+                                            // `constants.walletMaxBtcTransfer`) and the count of
+                                            // live wallets is `5`. We compute the expected target
+                                            // wallets count as:
+                                            // `N = min(liveWalletsCount, ceil(walletBtcBalance / walletMaxBtcTransfer))`
+                                            // so we have `N = min(5, 26 / 10) = min(5, 3) = 3`
+                                            const expectedTargetWalletsCount = 3;
+                                            context("when all target wallets are different than the source wallet", () => {
+                                                context("when all target wallets follow the expected order", () => {
+                                                    context("when all target wallets are in the Live state", () => {
+                                                        let tx;
+                                                        const targetWallets = liveWallets.slice(0, expectedTargetWalletsCount);
+                                                        before(async () => {
+                                                            await createSnapshot();
+                                                            tx = await bridge
+                                                                .connect(caller)
+                                                                .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, targetWallets);
+                                                        });
+                                                        after(async () => {
+                                                            await restoreSnapshot();
+                                                        });
+                                                        it("should store the target wallets commitment for the given wallet", async () => {
+                                                            (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160))
+                                                                .movingFundsTargetWalletsCommitmentHash).to.be.equal(hardhat_1.ethers.utils.solidityKeccak256(["bytes20[]"], [targetWallets]));
+                                                        });
+                                                        it("should emit the MovingFundsCommitmentSubmitted event", async () => {
+                                                            await (0, chai_1.expect)(tx)
+                                                                .to.emit(bridge, "MovingFundsCommitmentSubmitted")
+                                                                .withArgs(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, targetWallets, caller.address);
+                                                        });
+                                                    });
+                                                    context("when one of the target wallets is not in the Live state", () => {
+                                                        it("should revert", async () => {
+                                                            // Put an Unknown wallet into the mix.
+                                                            const targetWallets = [
+                                                                "0x2313e29d08e6b5e0d3cda040ed7f664ce9c840c4",
+                                                                liveWallets[0],
+                                                                liveWallets[1],
+                                                            ];
+                                                            await (0, chai_1.expect)(bridge
+                                                                .connect(caller)
+                                                                .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, targetWallets)).to.be.revertedWith("Submitted target wallet must be in Live state");
+                                                        });
+                                                    });
+                                                });
+                                                context("when one of the target wallets break the expected order", () => {
+                                                    it("should revert", async () => {
+                                                        const targetWallets = [
+                                                            liveWallets[0],
+                                                            liveWallets[1],
+                                                            liveWallets[1],
+                                                        ];
+                                                        await (0, chai_1.expect)(bridge
+                                                            .connect(caller)
+                                                            .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, targetWallets)).to.be.revertedWith("Submitted target wallet breaks the expected order");
+                                                    });
+                                                });
+                                            });
+                                            context("when one of the target wallets is same as the source wallet", () => {
+                                                it("should revert", async () => {
+                                                    const targetWallets = [
+                                                        liveWallets[0],
+                                                        ecdsa_1.ecdsaWalletTestData.pubKeyHash160,
+                                                        liveWallets[1],
+                                                    ];
+                                                    await (0, chai_1.expect)(bridge
+                                                        .connect(caller)
+                                                        .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, targetWallets)).to.be.revertedWith("Submitted target wallet cannot be equal to the source wallet");
+                                                });
+                                            });
+                                        });
+                                        context("when the submitted target wallets count is other than the expected", () => {
+                                            it("should revert", async () => {
+                                                await (0, chai_1.expect)(bridge
+                                                    .connect(caller)
+                                                    .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, [liveWallets[0], liveWallets[1]])).to.be.revertedWith("Submitted target wallets count is other than expected");
+                                            });
+                                        });
+                                    });
+                                    context("when the expected target wallets count is zero", () => {
+                                        it("should revert", async () => {
+                                            await (0, chai_1.expect)(
+                                            // The last parameter doesn't matter in this scenario.
+                                            bridge
+                                                .connect(caller)
+                                                .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo, walletMembersIDs, walletMemberIndex, [])).to.be.revertedWith("No target wallets available");
+                                        });
+                                    });
+                                });
+                                context("when wallet balance is zero", () => {
+                                    it("should revert", async () => {
+                                        await (0, chai_1.expect)(
+                                        // The last parameter doesn't matter in this scenario.
+                                        bridge.connect(caller).submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, // That makes the balance to be 0 BTC.
+                                        walletMembersIDs, walletMemberIndex, [])).to.be.revertedWith("Wallet BTC balance is zero");
+                                    });
+                                });
+                            });
+                            context("when passed wallet main UTXO is invalid", () => {
+                                const mainUtxo = {
+                                    txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                    txOutputIndex: 0,
+                                    txOutputValue: (0, contract_test_helpers_1.to1ePrecision)(26, 8), // 26 BTC
+                                };
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    // Changing the `txOutputValue` to a value other than `0` will
+                                    // make that scenario happen.
+                                    const corruptedMainUtxo = {
+                                        ...mainUtxo,
+                                        txOutputValue: 1,
+                                    };
+                                    await (0, chai_1.expect)(
+                                    // The last parameter doesn't matter in this scenario.
+                                    bridge
+                                        .connect(caller)
+                                        .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, corruptedMainUtxo, walletMembersIDs, walletMemberIndex, [])).to.be.revertedWith("Invalid wallet main UTXO data");
+                                });
+                            });
+                        });
+                        context("when the caller is not a member of the source wallet", () => {
+                            const walletMembersIDs = [1, 2, 3, 4, 5];
+                            const walletMemberIndex = 2;
+                            before(async () => {
+                                await createSnapshot();
+                                // That's the default behavior, but we just make it explicit.
+                                walletRegistry.isWalletMember.returns(false);
+                            });
+                            after(async () => {
+                                walletRegistry.isWalletMember.reset();
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(
+                                // The last parameter doesn't matter in this scenario.
+                                bridge
+                                    .connect(thirdParty)
+                                    .submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, walletMembersIDs, walletMemberIndex, [])).to.be.revertedWith("Caller is not a member of the source wallet");
+                            });
+                        });
+                    });
+                    context("when the commitment was already submitted", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ...walletDraft,
+                                state: fixtures_1.walletState.MovingFunds,
+                                // Set a non-zero commitment to make this scenario work.
+                                movingFundsTargetWalletsCommitmentHash: "0x959e95e0bd83d34878f77ead61cb4e955bf5e3bdc9e16cdfbd51c4c20ab7e6b4",
+                            });
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(
+                            // Parameters others than the first doesn't matter in this scenario.
+                            bridge.submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, [], 0, [])).to.be.revertedWith("Target wallets commitment already submitted");
+                        });
+                    });
+                });
+                context("when source wallet has pending moved funds sweep requests", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.MovingFunds,
+                            // Set non-zero pending requests count to make this scenario work.
+                            pendingMovedFundsSweepRequestsCount: 1,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(
+                        // Parameters others than the first doesn't matter in this scenario.
+                        bridge.submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, [], 0, [])).to.be.revertedWith("Source wallet must handle all pending moved funds sweep requests first");
+                    });
+                });
+            });
+            context("when source wallet has pending redemptions", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                        ...walletDraft,
+                        state: fixtures_1.walletState.MovingFunds,
+                        // Set non-zero pending redemptions value to make this scenario work.
+                        pendingRedemptionsValue: 10000,
+                    });
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(
+                    // Parameters others than the first doesn't matter in this scenario.
+                    bridge.submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, [], 0, [])).to.be.revertedWith("Source wallet must handle all pending redemptions first");
+                });
+            });
+        });
+        context("when source wallet is not in the MovingFunds state", () => {
+            const testData = [
+                {
+                    testName: "when the source wallet is in the Unknown state",
+                    state: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when the source wallet is in the Live state",
+                    state: fixtures_1.walletState.Live,
+                },
+                {
+                    testName: "when the source wallet is in the Closing state",
+                    state: fixtures_1.walletState.Closing,
+                },
+                {
+                    testName: "when the source wallet is in the Closed state",
+                    state: fixtures_1.walletState.Closed,
+                },
+                {
+                    testName: "when the source wallet is in the Terminated state",
+                    state: fixtures_1.walletState.Terminated,
+                },
+            ];
+            testData.forEach((test) => {
+                context(test.testName, () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: test.state,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(
+                        // Parameters other than the first doesn't matter in this scenario.
+                        bridge.submitMovingFundsCommitment(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO, [], 0, [])).to.be.revertedWith("Source wallet must be in MovingFunds state");
+                    });
+                });
+            });
+        });
+    });
+    describe("resetMovingFundsTimeout", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        context("when the wallet is in the MovingFunds state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.MovingFunds,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when the wallet's commitment is not submitted yet", () => {
+                context("when Live wallets count is zero", () => {
+                    // No need to do any specific setup. There is only one MovingFunds
+                    // wallet in the system and its commitment is not yet submitted.
+                    // Those preconditions are met by default.
+                    context("when reset delay has elapsed", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the timestamp of the block that contains the `setWallet` tx.
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ...(await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)),
+                                movingFundsRequestedAt: (await lastBlockTime()) + 1,
+                            });
+                            await increaseTime(movingFundsTimeoutResetDelay);
+                            tx = await bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should reset the moving funds timeout", async () => {
+                            (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160))
+                                .movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit MovingFundsTimeoutReset event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "MovingFundsTimeoutReset")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                    });
+                    context("when reset delay has not elapsed yet", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the timestamp of the block that contains the `setWallet` tx.
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ...(await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)),
+                                movingFundsRequestedAt: (await lastBlockTime()) + 1,
+                            });
+                            await increaseTime(movingFundsTimeoutResetDelay - 1);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Moving funds timeout cannot be reset yet");
+                        });
+                    });
+                    context("when one reset occurred and the reset delay has elapsed again", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the timestamp of the block that contains the `setWallet` tx.
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ...(await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)),
+                                movingFundsRequestedAt: (await lastBlockTime()) + 1,
+                            });
+                            await increaseTime(movingFundsTimeoutResetDelay);
+                            // Reset for the first time.
+                            await bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            // The reset delay elapses again.
+                            await increaseTime(movingFundsTimeoutResetDelay);
+                            // The next reset.
+                            tx = await bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should reset the moving funds timeout", async () => {
+                            (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160))
+                                .movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit MovingFundsTimeoutReset event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "MovingFundsTimeoutReset")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                    });
+                    context("when one reset occurred and the reset delay has not elapsed yet", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the timestamp of the block that contains the `setWallet` tx.
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ...(await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)),
+                                movingFundsRequestedAt: (await lastBlockTime()) + 1,
+                            });
+                            await increaseTime(movingFundsTimeoutResetDelay);
+                            // Reset for the first time.
+                            await bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            // The reset delay has not elapsed again yet.
+                            await increaseTime(movingFundsTimeoutResetDelay - 1);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Moving funds timeout cannot be reset yet");
+                        });
+                    });
+                });
+                context("when Live wallets count is not zero", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        // This call will add one Live wallet and increase the Live wallet
+                        // counter accordingly. Note that the wallet's public key hash
+                        // must be different from the PKH of the tested wallet.
+                        await bridge.setWallet("0x7ac2d9378a1c47e589dfb8095ca95ed2140d2726", {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Live wallets count must be zero");
+                    });
+                });
+            });
+            context("when the wallet's commitment is already submitted", () => {
+                before(async () => {
+                    await createSnapshot();
+                    // Set an arbitrary non-zero commitment.
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                        ...(await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)),
+                        movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.utils.solidityKeccak256(["bytes20"], ["0xc214a5e9ec1b7792af9894e8f9ff0dd9bf427d79"]),
+                    });
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Target wallets commitment already submitted");
+                });
+            });
+        });
+        context("when the wallet is not in the MovingFunds state", () => {
+            const testData = [
+                {
+                    testName: "when the wallet is in the Unknown state",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when the wallet is in the Live state",
+                    walletState: fixtures_1.walletState.Live,
+                },
+                {
+                    testName: "when the wallet is in the Closing state",
+                    walletState: fixtures_1.walletState.Closing,
+                },
+                {
+                    testName: "when the wallet is in the Closed state",
+                    walletState: fixtures_1.walletState.Closed,
+                },
+                {
+                    testName: "when the wallet is in the Terminated state",
+                    walletState: fixtures_1.walletState.Terminated,
+                },
+            ];
+            testData.forEach((test) => {
+                context(test.testName, () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: test.walletState,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.resetMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Wallet must be in MovingFunds state");
+                    });
+                });
+            });
+        });
+    });
+    describe("submitMovingFundsProof", () => {
+        context("when transaction proof is valid", () => {
+            context("when there is a main UTXO for the given wallet", () => {
+                context("when main UTXO data are valid", () => {
+                    context("when there is only one input", () => {
+                        context("when the single input points to the wallet's main UTXO", () => {
+                            context("when the output vector references only 20-byte hashes", () => {
+                                context("when the output vector has only P2PKH and P2WPKH outputs", () => {
+                                    context("when transaction amount is distributed evenly", () => {
+                                        context("when transaction fee is not too high", () => {
+                                            context("when source wallet is in the MovingFunds state", () => {
+                                                context("when target wallets commitment is submitted", () => {
+                                                    context("when actual target wallets correspond to the commitment", () => {
+                                                        const testData = [
+                                                            {
+                                                                testName: "when there is a single target wallet",
+                                                                data: moving_funds_1.SingleTargetWallet,
+                                                            },
+                                                            {
+                                                                testName: "when there are multiple target wallets and the amount is indivisible",
+                                                                data: moving_funds_1.MultipleTargetWalletsAndIndivisibleAmount,
+                                                            },
+                                                            {
+                                                                testName: "when there are multiple target wallets and the amount is divisible",
+                                                                data: moving_funds_1.MultipleTargetWalletsAndDivisibleAmount,
+                                                            },
+                                                        ];
+                                                        testData.forEach((test) => {
+                                                            context(test.testName, () => {
+                                                                let tx;
+                                                                before(async () => {
+                                                                    await createSnapshot();
+                                                                    tx =
+                                                                        await runMovingFundsScenario(test.data);
+                                                                });
+                                                                after(async () => {
+                                                                    await restoreSnapshot();
+                                                                });
+                                                                it("should mark the main UTXO as correctly spent", async () => {
+                                                                    const key = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                                        test.data.mainUtxo
+                                                                            .txHash,
+                                                                        test.data.mainUtxo
+                                                                            .txOutputIndex,
+                                                                    ]);
+                                                                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                                                                    (0, chai_1.expect)(await bridge.spentMainUTXOs(key)).to.be.true;
+                                                                });
+                                                                it("should unset the main UTXO for the source wallet", async () => {
+                                                                    (0, chai_1.expect)((await bridge.wallets(test.data.wallet
+                                                                        .pubKeyHash)).mainUtxoHash).to.be.equal(hardhat_1.ethers.constants.HashZero);
+                                                                });
+                                                                it("should put the source wallet in the Closing state", async () => {
+                                                                    (0, chai_1.expect)((await bridge.wallets(test.data.wallet
+                                                                        .pubKeyHash)).state).to.be.equal(fixtures_1.walletState.Closing);
+                                                                });
+                                                                it("should set the closing started timestamp", async () => {
+                                                                    (0, chai_1.expect)((await bridge.wallets(test.data.wallet
+                                                                        .pubKeyHash)).closingStartedAt).to.be.equal(await lastBlockTime());
+                                                                });
+                                                                it("should emit the WalletClosing event", async () => {
+                                                                    await (0, chai_1.expect)(tx)
+                                                                        .to.emit(bridge, "WalletClosing")
+                                                                        .withArgs(test.data.wallet
+                                                                        .ecdsaWalletID, test.data.wallet
+                                                                        .pubKeyHash);
+                                                                });
+                                                                it("should emit the MovingFundsCompleted event", async () => {
+                                                                    await (0, chai_1.expect)(tx)
+                                                                        .to.emit(bridge, "MovingFundsCompleted")
+                                                                        .withArgs(test.data.wallet
+                                                                        .pubKeyHash, test.data.movingFundsTx
+                                                                        .hash);
+                                                                });
+                                                                it("should create appropriate moved funds sweep requests", async () => {
+                                                                    for (let i = 0; i <
+                                                                        test.data
+                                                                            .expectedMovedFundsSweepRequests
+                                                                            .length; i++) {
+                                                                        const expectedMovedFundsSweepRequest = test.data
+                                                                            .expectedMovedFundsSweepRequests[i];
+                                                                        const requestKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                                            expectedMovedFundsSweepRequest.txHash,
+                                                                            expectedMovedFundsSweepRequest.txOutputIndex,
+                                                                        ]);
+                                                                        const actualMovedFundsSweepRequest = 
+                                                                        // eslint-disable-next-line no-await-in-loop
+                                                                        await bridge.movedFundsSweepRequests(requestKey);
+                                                                        (0, chai_1.expect)(actualMovedFundsSweepRequest.walletPubKeyHash).to.be.equal(expectedMovedFundsSweepRequest.walletPubKeyHash, `Unexpected wallet for sweep request ${i}`);
+                                                                        (0, chai_1.expect)(actualMovedFundsSweepRequest.value).to.be.equal(expectedMovedFundsSweepRequest.txOutputValue, `Unexpected value for sweep request ${i}`);
+                                                                        (0, chai_1.expect)(actualMovedFundsSweepRequest.createdAt).to.be.equal(
+                                                                        // eslint-disable-next-line no-await-in-loop
+                                                                        await lastBlockTime(), `Unexpected created timestamp for sweep request ${i}`);
+                                                                        (0, chai_1.expect)(actualMovedFundsSweepRequest.state).to.be.equal(fixtures_1.movedFundsSweepRequestState.Pending, `Unexpected state for sweep request ${i}`);
+                                                                        /* eslint-disable no-await-in-loop */
+                                                                        (0, chai_1.expect)((await bridge.wallets(expectedMovedFundsSweepRequest.walletPubKeyHash))
+                                                                            .pendingMovedFundsSweepRequestsCount).to.be.equal(1);
+                                                                        /* eslint-enable no-await-in-loop */
+                                                                    }
+                                                                });
+                                                            });
+                                                        });
+                                                    });
+                                                    context("when actual target wallets does not correspond to the commitment", () => {
+                                                        // The below test data send funds to
+                                                        // three wallets with the following
+                                                        // 20-byte PKHs (in this order):
+                                                        // - 0x2cd680318747b720d67bf4246eb7403b476adb34
+                                                        // - 0x8900de8fc6e4cd1db4c7ab0759d28503b4cb0ab1
+                                                        // - 0xaf7a841e055fc19bf31acf4cbed5ef548a2cc453
+                                                        // If the commitment is not exactly
+                                                        // this list, the moving funds proof
+                                                        // will revert.
+                                                        const data = moving_funds_1.MultipleTargetWalletsAndIndivisibleAmount;
+                                                        const testData = [
+                                                            {
+                                                                testName: "when funds were sent to more wallets than submitted in the commitment",
+                                                                modifyData: (dataCopy) => 
+                                                                // Simulate that the commitment
+                                                                // contains only the two first
+                                                                // wallets used in the transaction.
+                                                                ({
+                                                                    ...dataCopy,
+                                                                    targetWalletsCommitment: [
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[0],
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[1],
+                                                                    ],
+                                                                }),
+                                                            },
+                                                            {
+                                                                testName: "when funds were sent to less wallets than submitted in the commitment",
+                                                                modifyData: (dataCopy) => 
+                                                                // Simulate that the commitment
+                                                                // contains an additional wallet apart
+                                                                // from all wallets used in the transaction.
+                                                                ({
+                                                                    ...dataCopy,
+                                                                    targetWalletsCommitment: [
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[0],
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[1],
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[2],
+                                                                        "0xe04f5dbeafea147699fce4e0e12027aa0bc12e78",
+                                                                    ],
+                                                                }),
+                                                            },
+                                                            {
+                                                                testName: "when funds were sent to completely different wallets than submitted in the commitment",
+                                                                modifyData: (dataCopy) => 
+                                                                // Simulate that the commitment
+                                                                // contains three different wallets
+                                                                // than the wallets used in the
+                                                                // transaction.
+                                                                ({
+                                                                    ...dataCopy,
+                                                                    targetWalletsCommitment: [
+                                                                        "0x1e445df2d9136831193d90c5e2c6b7ea8a0882fb",
+                                                                        "0x9d134f065a6566bcc2f99fffe21856e129638526",
+                                                                        "0x4f524b05f817bd8f3be613ff5bc5ef87f0b68b46",
+                                                                    ],
+                                                                }),
+                                                            },
+                                                            {
+                                                                testName: "when funds were sent to the wallets submitted in the commitment but with a wrong order",
+                                                                modifyData: (dataCopy) => 
+                                                                // Simulate that the commitment
+                                                                // contains three different wallets
+                                                                // than the wallets used in the
+                                                                // transaction.
+                                                                ({
+                                                                    ...dataCopy,
+                                                                    targetWalletsCommitment: [
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[2],
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[1],
+                                                                        dataCopy
+                                                                            .targetWalletsCommitment[0],
+                                                                    ],
+                                                                }),
+                                                            },
+                                                        ];
+                                                        testData.forEach((test) => {
+                                                            context(test.testName, () => {
+                                                                let tx;
+                                                                before(async () => {
+                                                                    await createSnapshot();
+                                                                    // Pass a copy of the original data.
+                                                                    const modifiedData = test.modifyData(JSON.parse(JSON.stringify(data)));
+                                                                    tx =
+                                                                        runMovingFundsScenario(modifiedData);
+                                                                });
+                                                                after(async () => {
+                                                                    await restoreSnapshot();
+                                                                });
+                                                                it("should revert", async () => {
+                                                                    await (0, chai_1.expect)(tx).to.be.revertedWith("Target wallets don't correspond to the commitment");
+                                                                });
+                                                            });
+                                                        });
+                                                    });
+                                                });
+                                                context("when target wallets commitment is not submitted", () => {
+                                                    const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                                                    let tx;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                        tx = runMovingFundsScenario({
+                                                            ...data,
+                                                            targetWalletsCommitment: [],
+                                                        });
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Target wallets commitment not submitted yet");
+                                                    });
+                                                });
+                                            });
+                                            context("when source wallet is not in the MovingFunds state", () => {
+                                                const testData = [
+                                                    {
+                                                        testName: "when wallet state is Unknown",
+                                                        state: fixtures_1.walletState.Unknown,
+                                                    },
+                                                    {
+                                                        testName: "when wallet state is Live",
+                                                        state: fixtures_1.walletState.Live,
+                                                    },
+                                                    {
+                                                        testName: "when wallet state is Closing",
+                                                        state: fixtures_1.walletState.Closing,
+                                                    },
+                                                    {
+                                                        testName: "when wallet state is Closed",
+                                                        state: fixtures_1.walletState.Closed,
+                                                    },
+                                                    {
+                                                        testName: "when wallet state is Terminated",
+                                                        state: fixtures_1.walletState.Terminated,
+                                                    },
+                                                ];
+                                                testData.forEach((test) => {
+                                                    context(test.testName, () => {
+                                                        const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                                                        let tx;
+                                                        before(async () => {
+                                                            await createSnapshot();
+                                                            data.wallet.state = test.state;
+                                                            tx = runMovingFundsScenario(data);
+                                                        });
+                                                        after(async () => {
+                                                            await restoreSnapshot();
+                                                        });
+                                                        it("should revert", async () => {
+                                                            await (0, chai_1.expect)(tx).to.be.revertedWith("Wallet must be in MovingFunds state");
+                                                        });
+                                                    });
+                                                });
+                                            });
+                                        });
+                                        context("when transaction fee is too high", () => {
+                                            const data = moving_funds_1.SingleTargetWallet;
+                                            let tx;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                const beforeProofActions = async () => {
+                                                    // The transaction used by this scenario's
+                                                    // test data has a fee of 9000 satoshis. Lowering
+                                                    // the max fee in the Bridge by one should
+                                                    // cause the expected failure.
+                                                    await bridge.setMovingFundsTxMaxTotalFee(8999);
+                                                };
+                                                tx = runMovingFundsScenario(data, beforeProofActions);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                await (0, chai_1.expect)(tx).to.be.revertedWith("Transaction fee is too high");
+                                            });
+                                        });
+                                    });
+                                    context("when transaction amount is not distributed evenly", () => {
+                                        const data = moving_funds_1.MultipleTargetWalletsButAmountDistributedUnevenly;
+                                        let tx;
+                                        before(async () => {
+                                            await createSnapshot();
+                                            tx = runMovingFundsScenario(data);
+                                        });
+                                        after(async () => {
+                                            await restoreSnapshot();
+                                        });
+                                        it("should revert", async () => {
+                                            await (0, chai_1.expect)(tx).to.be.revertedWith("Transaction amount is not distributed evenly");
+                                        });
+                                    });
+                                });
+                                context("when the output vector contains P2SH output", () => {
+                                    // The only possible case is P2SH which contains the
+                                    // 20-byte payload, just like P2PKH and P2WPKH.
+                                    // No need to check P2WSH as it uses a 32-byte payload
+                                    // so it would fail earlier, at the payload length
+                                    // assertion.
+                                    const data = moving_funds_1.SingleTargetWalletButP2SH;
+                                    let tx;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        tx = runMovingFundsScenario(data);
+                                    });
+                                    after(async () => {
+                                        await restoreSnapshot();
+                                    });
+                                    it("should revert", async () => {
+                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Output must be P2PKH or P2WPKH");
+                                    });
+                                });
+                            });
+                            context("when the output vector does not only reference 20-byte hashes", () => {
+                                // Use a provably unspendable output whose payload length
+                                // is zero so it should cause a failure upon the assertion
+                                // that makes sure the output payload is 20-byte.
+                                const data = moving_funds_1.SingleProvablyUnspendable;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    tx = runMovingFundsScenario(data);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(tx).to.be.revertedWith("Output's public key hash must have 20 bytes");
+                                });
+                            });
+                        });
+                        context("when the single input doesn't point to the wallet's main UTXO", () => {
+                            const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                            let tx;
+                            before(async () => {
+                                await createSnapshot();
+                                // Corrupt the wallet's main UTXO that is injected to
+                                // the Bridge state by the test runner in order to make it
+                                // different than the input used by the actual Bitcoin
+                                // transaction thus make the tested scenario happen. The
+                                // proper value of `txOutputIndex` is `1` so any other value
+                                // will do the trick.
+                                data.mainUtxo.txOutputIndex = 0;
+                                tx = runMovingFundsScenario(data);
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(tx).to.be.revertedWith("Outbound transaction input must point to the wallet's main UTXO");
+                            });
+                        });
+                    });
+                    context("when input count is other than one", () => {
+                        const data = moving_funds_1.MultipleInputs;
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            tx = runMovingFundsScenario(data);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(tx).to.be.revertedWith("Outbound transaction must have a single input");
+                        });
+                    });
+                });
+                context("when main UTXO data are invalid", () => {
+                    const data = moving_funds_1.SingleTargetWallet;
+                    before(async () => {
+                        await createSnapshot();
+                        // Required for a successful SPV proof.
+                        relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                        relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                        // Wallet main UTXO must be set on the Bridge side to make
+                        // that scenario happen.
+                        await bridge.setWalletMainUtxo(data.wallet.pubKeyHash, data.mainUtxo);
+                    });
+                    after(async () => {
+                        relay.getPrevEpochDifficulty.reset();
+                        relay.getCurrentEpochDifficulty.reset();
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        // Corrupt the main UTXO parameter passed during
+                        // `submitMovingFundsProof` call. The proper value of
+                        // `txOutputIndex` for this test data set is `1` so any other
+                        // value will make this test scenario happen.
+                        const corruptedMainUtxo = {
+                            ...data.mainUtxo,
+                            txOutputIndex: 0,
+                        };
+                        await (0, chai_1.expect)(bridge.submitMovingFundsProof(data.movingFundsTx, data.movingFundsProof, corruptedMainUtxo, data.wallet.pubKeyHash)).to.be.revertedWith("Invalid main UTXO data");
+                    });
+                });
+            });
+            context("when there is no main UTXO for the given wallet", () => {
+                const data = moving_funds_1.SingleTargetWallet;
+                before(async () => {
+                    await createSnapshot();
+                    // Required for a successful SPV proof.
+                    relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                    relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                });
+                after(async () => {
+                    relay.getPrevEpochDifficulty.reset();
+                    relay.getCurrentEpochDifficulty.reset();
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // There was no preparations before `submitMovingFundsProof` call
+                    // so no main UTXO is set for the given wallet.
+                    await (0, chai_1.expect)(bridge.submitMovingFundsProof(data.movingFundsTx, data.movingFundsProof, data.mainUtxo, data.wallet.pubKeyHash)).to.be.revertedWith("No main UTXO for given wallet");
+                });
+            });
+        });
+        context("when transaction proof is not valid", () => {
+            context("when input vector is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the input vector by setting a compactSize uint claiming
+                    // there is no inputs at all.
+                    data.movingFundsTx.inputVector =
+                        "0x00b69a2869840aa6fdfd143136ff4514ca46ea2d876855040892ad74ab" +
+                            "8c5274220100000000ffffffff";
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Invalid input vector provided");
+                });
+            });
+            context("when output vector is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the output vector by setting a compactSize uint claiming
+                    // there is no outputs at all.
+                    data.movingFundsTx.outputVector =
+                        "0x005cf511000000000017a91486884e6be1525dab5ae0b451bd2c72cee6" +
+                            "7dcf4187";
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Invalid output vector provided");
+                });
+            });
+            context("when merkle proof is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the merkle proof by changing tx index in block to an
+                    // invalid one. The proper one is 1 so any other will do the trick.
+                    data.movingFundsProof.txIndexInBlock = 30;
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Tx merkle proof is not valid for provided header and tx hash");
+                });
+            });
+            context("when proof difficulty is not current nor previous", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // To pass the proof validation, the difficulty returned by the relay
+                    // must be 21461933 for test data used in this scenario. Setting
+                    // a different value will cause difficulty comparison failure.
+                    data.chainDifficulty = 2;
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Not at current or previous difficulty");
+                });
+            });
+            context("when headers chain length is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the bitcoin headers length in the moving funds proof. The
+                    // proper value is length divisible by 80 so any length violating
+                    // this rule will cause failure. In this case, we just remove the
+                    // last byte from proper headers chain.
+                    const properHeaders = data.movingFundsProof.bitcoinHeaders.toString();
+                    data.movingFundsProof.bitcoinHeaders = properHeaders.substring(0, properHeaders.length - 2);
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Invalid length of the headers chain");
+                });
+            });
+            context("when headers chain is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Bitcoin headers must form a chain to pass the proof validation.
+                    // That means the `previous block hash` encoded in the given block
+                    // header must match the actual previous header's hash. To test
+                    // that scenario, we corrupt the `previous block hash` of the
+                    // second header. Each header is 80 bytes length. First 4 bytes
+                    // of each header is `version` and 32 subsequent bytes is
+                    // `previous block hash`. Changing byte 85 of the whole chain will
+                    // do the work.
+                    const properHeaders = data.movingFundsProof.bitcoinHeaders.toString();
+                    data.movingFundsProof.bitcoinHeaders = `${properHeaders.substring(0, 170)}ff${properHeaders.substring(172)}`;
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Invalid headers chain");
+                });
+            });
+            context("when the work in the header is insufficient", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Each header encodes a `difficulty target` field in bytes 72-76.
+                    // The given header's hash (interpreted as uint) must be bigger than
+                    // the `difficulty target`. To test this scenario, we change the
+                    // last byte of the last header in such a way their hash becomes
+                    // lower than their `difficulty target`.
+                    const properHeaders = data.movingFundsProof.bitcoinHeaders.toString();
+                    data.movingFundsProof.bitcoinHeaders = `${properHeaders.substring(0, properHeaders.length - 2)}ff`;
+                    await (0, chai_1.expect)(runMovingFundsScenario(data)).to.be.revertedWith("Insufficient work in a header");
+                });
+            });
+            context("when accumulated difficulty in headers chain is insufficient", () => {
+                let otherBridge;
+                const data = JSON.parse(JSON.stringify(moving_funds_1.SingleTargetWallet));
+                before(async () => {
+                    await createSnapshot();
+                    // Necessary to pass the first part of proof validation.
+                    relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                    relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                    // Deploy another bridge which has higher `txProofDifficultyFactor`
+                    // than the original bridge. That means it will need 12 confirmations
+                    // to deem transaction proof validity. This scenario uses test
+                    // data which has only 6 confirmations. That should force the
+                    // failure we expect within this scenario.
+                    otherBridge = await BridgeFactory.deploy();
+                    await otherBridge.initialize(bank.address, relay.address, treasury.address, walletRegistry.address, 12);
+                });
+                after(async () => {
+                    relay.getCurrentEpochDifficulty.reset();
+                    relay.getPrevEpochDifficulty.reset();
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(otherBridge.submitMovingFundsProof(data.movingFundsTx, data.movingFundsProof, data.mainUtxo, data.wallet.pubKeyHash)).to.be.revertedWith("Insufficient accumulated difficulty in header chain");
+                });
+            });
+        });
+    });
+    describe("notifyMovingFundsTimeout", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        context("when source wallet is in the MovingFunds state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.Live,
+                });
+                // Wallet must have funds to be not closed immediately by
+                // the following `__ecdsaWalletHeartbeatFailedCallback` call.
+                await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    txHash: hardhat_1.ethers.constants.HashZero,
+                    txOutputIndex: 0,
+                    txOutputValue: (0, contract_test_helpers_1.to1ePrecision)(10, 8),
+                });
+                // Switches the wallet to moving funds.
+                await bridge
+                    .connect(walletRegistry.wallet)
+                    .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when the moving funds process has timed out", () => {
+                let tx;
+                const walletMembersIDs = [1, 2, 3, 4, 5];
+                before(async () => {
+                    await createSnapshot();
+                    walletRegistry.closeWallet.reset();
+                    walletRegistry.seize.reset();
+                    await increaseTime(movingFundsTimeout);
+                    tx = await bridge
+                        .connect(thirdParty)
+                        .notifyMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMembersIDs);
+                });
+                after(async () => {
+                    walletRegistry.closeWallet.reset();
+                    walletRegistry.seize.reset();
+                    await restoreSnapshot();
+                });
+                it("should switch the wallet to Terminated state", async () => {
+                    (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).state).to.be.equal(fixtures_1.walletState.Terminated);
+                });
+                it("should emit WalletTerminated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "WalletTerminated")
+                        .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+                it("should call ECDSA Wallet Registry's closeWallet function", async () => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                    (0, chai_1.expect)(walletRegistry.closeWallet).to.have.been.calledOnceWith(ecdsa_1.ecdsaWalletTestData.walletID);
+                });
+                it("should call the ECDSA wallet registry's seize function", async () => {
+                    (0, chai_1.expect)(walletRegistry.seize).to.have.been.calledOnceWith(movingFundsTimeoutSlashingAmount, movingFundsTimeoutNotifierRewardMultiplier, await thirdParty.getAddress(), ecdsa_1.ecdsaWalletTestData.walletID, walletMembersIDs);
+                });
+                it("should emit MovingFundsTimedOut event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "MovingFundsTimedOut")
+                        .withArgs(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+            });
+            context("when the moving funds process has not timed out", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await increaseTime(movingFundsTimeout - 1);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, [])).to.be.revertedWith("Moving funds has not timed out yet");
+                });
+            });
+        });
+        context("when source wallet is not in the MovingFunds state", () => {
+            const testData = [
+                {
+                    testName: "when the source wallet is in the Unknown state",
+                    state: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when the source wallet is in the Live state",
+                    state: fixtures_1.walletState.Live,
+                },
+                {
+                    testName: "when the source wallet is in the Closing state",
+                    state: fixtures_1.walletState.Closing,
+                },
+                {
+                    testName: "when the source wallet is in the Closed state",
+                    state: fixtures_1.walletState.Closed,
+                },
+                {
+                    testName: "when the source wallet is in the Terminated state",
+                    state: fixtures_1.walletState.Terminated,
+                },
+            ];
+            testData.forEach((test) => {
+                context(test.testName, () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: test.state,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.notifyMovingFundsTimeout(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, [])).to.be.revertedWith("Wallet must be in MovingFunds state");
+                    });
+                });
+            });
+        });
+    });
+    describe("notifyMovingFundsBelowDust", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        context("when the wallet is in the MovingFunds state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.MovingFunds,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when the main UTXO parameter is valid", () => {
+                context("when the balance is below the dust threshold", () => {
+                    const mainUtxo = {
+                        txHash: hardhat_1.ethers.constants.HashZero,
+                        txOutputIndex: 0,
+                        txOutputValue: fixtures_1.constants.movingFundsDustThreshold - 1,
+                    };
+                    let tx;
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                        tx = await bridge.notifyMovingFundsBelowDust(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should change wallet's state to Closing", async () => {
+                        const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.Closing);
+                    });
+                    it("should set the wallet's closing started timestamp", async () => {
+                        const wallet = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        (0, chai_1.expect)(wallet.closingStartedAt).to.be.equal(await lastBlockTime());
+                    });
+                    it("should emit WalletClosing event", async () => {
+                        await (0, chai_1.expect)(tx)
+                            .to.emit(bridge, "WalletClosing")
+                            .withArgs(walletDraft.ecdsaWalletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                    });
+                    it("should emit MovingFundsBelowDustReported event", async () => {
+                        await (0, chai_1.expect)(tx)
+                            .to.emit(bridge, "MovingFundsBelowDustReported")
+                            .withArgs(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                    });
+                });
+                context("when the balance is not below the dust threshold", () => {
+                    const mainUtxo = {
+                        txHash: hardhat_1.ethers.constants.HashZero,
+                        txOutputIndex: 0,
+                        txOutputValue: fixtures_1.constants.movingFundsDustThreshold,
+                    };
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.notifyMovingFundsBelowDust(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo)).to.be.revertedWith("Wallet BTC balance must be below the moving funds dust threshold");
+                    });
+                });
+            });
+            context("when the main UTXO parameter is invalid", () => {
+                const mainUtxo = {
+                    txHash: hardhat_1.ethers.constants.HashZero,
+                    txOutputIndex: 0,
+                    txOutputValue: (0, contract_test_helpers_1.to1ePrecision)(1, 8),
+                };
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                        ...walletDraft,
+                        state: fixtures_1.walletState.MovingFunds,
+                    });
+                    await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, mainUtxo);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    const corruptedMainUtxo = {
+                        ...mainUtxo,
+                        txOutputIndex: 1,
+                    };
+                    await (0, chai_1.expect)(bridge.notifyMovingFundsBelowDust(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, corruptedMainUtxo)).to.be.revertedWith("Invalid wallet main UTXO data");
+                });
+            });
+        });
+        context("when the wallet is not in the MovingFunds state", () => {
+            const testData = [
+                {
+                    testName: "when wallet state is Unknown",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when wallet state is Live",
+                    walletState: fixtures_1.walletState.Live,
+                },
+                {
+                    testName: "when wallet state is Closing",
+                    walletState: fixtures_1.walletState.Closing,
+                },
+                {
+                    testName: "when wallet state is Closed",
+                    walletState: fixtures_1.walletState.Closed,
+                },
+                {
+                    testName: "when wallet state is Terminated",
+                    walletState: fixtures_1.walletState.Terminated,
+                },
+            ];
+            testData.forEach((test) => {
+                context(test.testName, () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: test.walletState,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.notifyMovingFundsBelowDust(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO)).to.be.revertedWith("Wallet must be in MovingFunds state");
+                    });
+                });
+            });
+        });
+    });
+    describe("submitMovedFundsSweepProof", () => {
+        context("when transaction proof is valid", () => {
+            context("when there is only one output", () => {
+                context("when the single output is 20-byte", () => {
+                    context("when single output is either P2PKH or P2WPKH", () => {
+                        context("when sweeping wallet is either in the Live or MovingFunds state", () => {
+                            context("when sweeping wallet is in the Live state", () => {
+                                context("when main UTXO data are valid", () => {
+                                    context("when transaction fee does not exceed the sweep transaction maximum fee", () => {
+                                        context("when the sweeping wallet has no main UTXO set", () => {
+                                            context("when there is a single input referring to a Pending sweep request", () => {
+                                                const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                let tx;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                    tx = await runMovedFundsSweepScenario(data);
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should mark the sweep request as processed", async () => {
+                                                    const key = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.movedFundsSweepRequest.txHash,
+                                                        data.movedFundsSweepRequest.txOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                                                    (0, chai_1.expect)((await bridge.movedFundsSweepRequests(key))
+                                                        .state).to.be.equal(fixtures_1.movedFundsSweepRequestState.Processed);
+                                                });
+                                                it("should decrease the sweeping wallet's pending requests count", async () => {
+                                                    // The `setPendingMovedFundsSweepRequest` call
+                                                    // made as part of `runMovedFundsSweepScenario`
+                                                    // set this counter to 1. Eventually, it
+                                                    // should be decreased back to 0.
+                                                    (0, chai_1.expect)((await bridge.wallets(data.wallet.pubKeyHash)).pendingMovedFundsSweepRequestsCount).to.be.equal(0);
+                                                });
+                                                it("should set the transaction output as new sweeping wallet main UTXO", async () => {
+                                                    // Amount can be checked by opening the sweep tx
+                                                    // in a Bitcoin testnet explorer. In this case,
+                                                    // the output  value is 16500.
+                                                    const expectedMainUtxoHash = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 16500]);
+                                                    (0, chai_1.expect)((await bridge.wallets(data.wallet.pubKeyHash)).mainUtxoHash).to.be.equal(expectedMainUtxoHash);
+                                                });
+                                                it("should emit the MovedFundsSwept event", async () => {
+                                                    await (0, chai_1.expect)(tx)
+                                                        .to.emit(bridge, "MovedFundsSwept")
+                                                        .withArgs(data.wallet.pubKeyHash, data.sweepTx.hash);
+                                                });
+                                            });
+                                            context("when the single input does not refer to a Pending sweep request", () => {
+                                                context("when the single input refers to an Unknown sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        // Getting rid of the `movedFundsSweepRequest`
+                                                        // allows running that scenario because
+                                                        // the sweep request will not exist in the system.
+                                                        await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                            ...data,
+                                                            movedFundsSweepRequest: null,
+                                                        })).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                                context("when the single input refers to a Processed sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                    let tx;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                        const beforeProofActions = async () => {
+                                                            await bridge.processPendingMovedFundsSweepRequest(data.movedFundsSweepRequest
+                                                                .walletPubKeyHash, data.movedFundsSweepRequest);
+                                                        };
+                                                        tx = runMovedFundsSweepScenario(data, beforeProofActions);
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                                context("when the single input refers to a TimedOut sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                    let tx;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                        const beforeProofActions = async () => {
+                                                            await bridge.timeoutPendingMovedFundsSweepRequest(data.movedFundsSweepRequest
+                                                                .walletPubKeyHash, data.movedFundsSweepRequest);
+                                                        };
+                                                        tx = runMovedFundsSweepScenario(data, beforeProofActions);
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                            });
+                                            context("when the single input does refer to a Pending sweep request that belongs to another wallet", () => {
+                                                const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // To make this scenario happen, we just
+                                                    // change the wallet in the test data' sweep
+                                                    // request.
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        movedFundsSweepRequest: {
+                                                            ...data.movedFundsSweepRequest,
+                                                            walletPubKeyHash: "0x7ac2d9378a1c47e589dfb8095ca95ed2140d2726",
+                                                        },
+                                                    })).to.be.revertedWith("Sweep request belongs to another wallet");
+                                                });
+                                            });
+                                            context("when the number of inputs is other than one", () => {
+                                                // Use a test data that contains a two-input
+                                                // transaction.
+                                                const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // However, do not set wallet main UTXO. In
+                                                    // that case, the system will expect a
+                                                    // sweep transaction with a single input.
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        mainUtxo: deposit_sweep_1.NO_MAIN_UTXO,
+                                                    })).to.be.revertedWith("Moved funds sweep transaction must have a proper inputs count");
+                                                });
+                                            });
+                                        });
+                                        context("when the sweeping wallet has a main UTXO set", () => {
+                                            context("when the first input refers to a Pending sweep request and the second input refers to the sweeping wallet main UTXO", () => {
+                                                const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                let tx;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                    tx = await runMovedFundsSweepScenario(data);
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should mark the sweep request as processed", async () => {
+                                                    const key = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.movedFundsSweepRequest.txHash,
+                                                        data.movedFundsSweepRequest.txOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                                                    (0, chai_1.expect)((await bridge.movedFundsSweepRequests(key))
+                                                        .state).to.be.equal(fixtures_1.movedFundsSweepRequestState.Processed);
+                                                });
+                                                it("should decrease the sweeping wallet's pending requests count", async () => {
+                                                    // The `setPendingMovedFundsSweepRequest` call
+                                                    // made as part of `runMovedFundsSweepScenario`
+                                                    // set this counter to 1. Eventually, it
+                                                    // should be decreased back to 0.
+                                                    (0, chai_1.expect)((await bridge.wallets(data.wallet.pubKeyHash)).pendingMovedFundsSweepRequestsCount).to.be.equal(0);
+                                                });
+                                                it("should set the transaction output as new sweeping wallet main UTXO", async () => {
+                                                    // Amount can be checked by opening the sweep tx
+                                                    // in a Bitcoin testnet explorer. In this case,
+                                                    // the output  value is 2612530.
+                                                    const expectedMainUtxoHash = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 2612530]);
+                                                    (0, chai_1.expect)((await bridge.wallets(data.wallet.pubKeyHash)).mainUtxoHash).to.be.equal(expectedMainUtxoHash);
+                                                });
+                                                it("should emit the MovedFundsSwept event", async () => {
+                                                    await (0, chai_1.expect)(tx)
+                                                        .to.emit(bridge, "MovedFundsSwept")
+                                                        .withArgs(data.wallet.pubKeyHash, data.sweepTx.hash);
+                                                });
+                                                it("should mark the current sweeping wallet main UTXO as correctly spent", async () => {
+                                                    const key = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.mainUtxo.txHash,
+                                                        data.mainUtxo.txOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                                                    (0, chai_1.expect)(await bridge.spentMainUTXOs(key)).to.be
+                                                        .true;
+                                                });
+                                            });
+                                            context("when the first input refers to the sweeping wallet main UTXO and the second input refers to a Pending sweep request", () => {
+                                                // The sweep transaction used by this test data
+                                                // has two inputs. The first input is registered
+                                                // as a sweep request (i.e. it is referred by
+                                                // `movedFundsSweepRequest`) and the second one
+                                                // is meant to be the main UTXO (i.e. it is
+                                                // referred by `mainUtxo`).
+                                                const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // To make that scenario happen, we just
+                                                    // let the test runner to register the first
+                                                    // input as the main UTXO and the second
+                                                    // one as the sweep request.
+                                                    const movedFundsSweepRequest = {
+                                                        ...data.mainUtxo,
+                                                        walletPubKeyHash: data.movedFundsSweepRequest
+                                                            .walletPubKeyHash,
+                                                    };
+                                                    const mainUtxo = {
+                                                        ...data.movedFundsSweepRequest,
+                                                    };
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        movedFundsSweepRequest,
+                                                        mainUtxo,
+                                                    })).to.be.revertedWith("Sweep request must be in Pending state");
+                                                });
+                                            });
+                                            context("when the first input does not refer to a Pending sweep request and the second input refers to the sweeping wallet main UTXO", () => {
+                                                context("when the first input refers to an Unknown sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        // Getting rid of the `movedFundsSweepRequest`
+                                                        // allows running that scenario because
+                                                        // the sweep request will not exist in the system.
+                                                        await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                            ...data,
+                                                            movedFundsSweepRequest: null,
+                                                        })).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                                context("when the first input refers to a Processed sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                    let tx;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                        const beforeProofActions = async () => {
+                                                            await bridge.processPendingMovedFundsSweepRequest(data.movedFundsSweepRequest
+                                                                .walletPubKeyHash, data.movedFundsSweepRequest);
+                                                        };
+                                                        tx = runMovedFundsSweepScenario(data, beforeProofActions);
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                                context("when the first input refers to a TimedOut sweep request", () => {
+                                                    const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                    let tx;
+                                                    before(async () => {
+                                                        await createSnapshot();
+                                                        const beforeProofActions = async () => {
+                                                            await bridge.timeoutPendingMovedFundsSweepRequest(data.movedFundsSweepRequest
+                                                                .walletPubKeyHash, data.movedFundsSweepRequest);
+                                                        };
+                                                        tx = runMovedFundsSweepScenario(data, beforeProofActions);
+                                                    });
+                                                    after(async () => {
+                                                        await restoreSnapshot();
+                                                    });
+                                                    it("should revert", async () => {
+                                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Sweep request must be in Pending state");
+                                                    });
+                                                });
+                                            });
+                                            context("when the first input refers to a Pending sweep request that belongs to another wallet and the second input refers to the sweeping wallet main UTXO", () => {
+                                                const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // To make this scenario happen, we just
+                                                    // change the wallet in the test data' sweep
+                                                    // request.
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        movedFundsSweepRequest: {
+                                                            ...data.movedFundsSweepRequest,
+                                                            walletPubKeyHash: "0x8db50eb52063ea9d98b3eac91489a90f738986f6",
+                                                        },
+                                                    })).to.be.revertedWith("Sweep request belongs to another wallet");
+                                                });
+                                            });
+                                            context("when the first input refers to a Pending sweep request and the second input does not refer to the sweeping wallet main UTXO", () => {
+                                                const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // To make this scenario happen, we just need
+                                                    // to simulate that the sweeping wallet has
+                                                    // a different main UTXO than the one used
+                                                    // by the second transaction input.
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        mainUtxo: {
+                                                            ...data.mainUtxo,
+                                                            txOutputIndex: 2,
+                                                        },
+                                                    })).to.be.revertedWith("Second input must point to the wallet's main UTXO");
+                                                });
+                                            });
+                                            context("when the number of inputs is other than two", () => {
+                                                // Use a test data with a one-input transaction.
+                                                const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                                before(async () => {
+                                                    await createSnapshot();
+                                                });
+                                                after(async () => {
+                                                    await restoreSnapshot();
+                                                });
+                                                it("should revert", async () => {
+                                                    // However, register a main UTXO for the
+                                                    // sweeping wallet in order to force the
+                                                    // system to expect a two-input transaction
+                                                    // for that sweeping wallet.
+                                                    await (0, chai_1.expect)(runMovedFundsSweepScenario({
+                                                        ...data,
+                                                        // Just an arbitrary main UTXO
+                                                        mainUtxo: {
+                                                            txHash: "0x7d5f7d4ae705d6adb8a402e5cd7f25f839a3f3ed243a8961c8ac5887d5aaf528",
+                                                            txOutputIndex: 0,
+                                                            txOutputValue: 873510,
+                                                        },
+                                                    })).to.be.revertedWith("Moved funds sweep transaction must have a proper inputs count");
+                                                });
+                                            });
+                                        });
+                                    });
+                                    context("when transaction fee exceeds the sweep transaction maximum fee", () => {
+                                        // Use a test data where the sweep transaction has
+                                        // a fee of 2000 satoshi.
+                                        const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                        before(async () => {
+                                            await createSnapshot();
+                                            // Set the max fee to one satoshi less than the fee
+                                            // used by the transaction.
+                                            await bridge.setMovedFundsSweepTxMaxTotalFee(1999);
+                                        });
+                                        after(async () => {
+                                            await restoreSnapshot();
+                                        });
+                                        it("should revert", async () => {
+                                            await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Transaction fee is too high");
+                                        });
+                                    });
+                                });
+                                context("when main UTXO data are invalid", () => {
+                                    const data = moving_funds_1.MovedFundsSweepWithMainUtxo;
+                                    let tx;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        const beforeProofAction = async () => {
+                                            // Swap the main UTXO just before the proof to make
+                                            // this scenario happen.
+                                            await bridge.setWalletMainUtxo(data.wallet.pubKeyHash, {
+                                                ...data.mainUtxo,
+                                                txOutputIndex: 2,
+                                            });
+                                        };
+                                        tx = runMovedFundsSweepScenario(data, beforeProofAction);
+                                    });
+                                    after(async () => {
+                                        await restoreSnapshot();
+                                    });
+                                    it("should revert", async () => {
+                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Invalid main UTXO data");
+                                    });
+                                });
+                            });
+                            context("when sweeping wallet is in the MovingFunds state", () => {
+                                const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    tx = runMovedFundsSweepScenario({
+                                        ...data,
+                                        wallet: {
+                                            ...data.wallet,
+                                            state: fixtures_1.walletState.MovingFunds,
+                                        },
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should succeed", async () => {
+                                    // The assertions were already performed for Live wallet
+                                    // scenarios. Here we just make sure the transaction
+                                    // succeeds for a MovingFunds wallet.
+                                    await (0, chai_1.expect)(tx).to.not.be.reverted;
+                                });
+                            });
+                        });
+                        context("when sweeping wallet is neither in the Live nor MovingFunds state", () => {
+                            const testData = [
+                                {
+                                    testName: "when sweeping wallet is in the Unknown state",
+                                    walletState: fixtures_1.walletState.Unknown,
+                                },
+                                {
+                                    testName: "when sweeping wallet is in the Closing state",
+                                    walletState: fixtures_1.walletState.Closing,
+                                },
+                                {
+                                    testName: "when sweeping wallet is in the Closed state",
+                                    walletState: fixtures_1.walletState.Closed,
+                                },
+                                {
+                                    testName: "when sweeping wallet is in the Terminated state",
+                                    walletState: fixtures_1.walletState.Terminated,
+                                },
+                            ];
+                            testData.forEach((test) => {
+                                context(test.testName, () => {
+                                    const data = moving_funds_1.MovedFundsSweepWithoutMainUtxo;
+                                    let tx;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        tx = runMovedFundsSweepScenario({
+                                            ...data,
+                                            wallet: {
+                                                ...data.wallet,
+                                                state: test.walletState,
+                                            },
+                                        });
+                                    });
+                                    after(async () => {
+                                        await restoreSnapshot();
+                                    });
+                                    it("should revert", async () => {
+                                        await (0, chai_1.expect)(tx).to.be.revertedWith("Wallet must be in Live or MovingFunds state");
+                                    });
+                                });
+                            });
+                        });
+                    });
+                    context("when single output is neither P2PKH nor P2WPKH", () => {
+                        const data = moving_funds_1.MovedFundsSweepP2SHOutput;
+                        before(async () => {
+                            await createSnapshot();
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Output must be P2PKH or P2WPKH");
+                        });
+                    });
+                });
+                context("when the single output is not 20-byte", () => {
+                    const data = moving_funds_1.MovedFundsSweepProvablyUnspendableOutput;
+                    before(async () => {
+                        await createSnapshot();
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Output's public key hash must have 20 bytes");
+                    });
+                });
+            });
+            context("when output count is other than one", () => {
+                const data = moving_funds_1.MovedFundsSweepMultipleOutputs;
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Moved funds sweep transaction must have a single output");
+                });
+            });
+        });
+        context("when transaction proof is not valid", () => {
+            context("when input vector is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the input vector by setting a compactSize uint claiming
+                    // there are no inputs at all.
+                    data.sweepTx.inputVector =
+                        "0x00b69a2869840aa6fdfd143136ff4514ca46ea2d876855040892ad74ab" +
+                            "8c5274220100000000ffffffff";
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Invalid input vector provided");
+                });
+            });
+            context("when output vector is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the output vector by setting a compactSize uint claiming
+                    // there is no outputs at all.
+                    data.sweepTx.outputVector =
+                        "0x005cf511000000000017a91486884e6be1525dab5ae0b451bd2c72cee6" +
+                            "7dcf4187";
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Invalid output vector provided");
+                });
+            });
+            context("when merkle proof is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the merkle proof by changing tx index in block to an
+                    // invalid one. The proper one is 12 so any other will do the trick.
+                    data.sweepProof.txIndexInBlock = 30;
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Tx merkle proof is not valid for provided header and tx hash");
+                });
+            });
+            context("when proof difficulty is not current nor previous", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // To pass the proof validation, the difficulty returned by the relay
+                    // must be 1 for test data used in this scenario. Setting
+                    // a different value will cause difficulty comparison failure.
+                    data.chainDifficulty = 2;
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Not at current or previous difficulty");
+                });
+            });
+            context("when headers chain length is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Corrupt the bitcoin headers length in the moving funds proof. The
+                    // proper value is length divisible by 80 so any length violating
+                    // this rule will cause failure. In this case, we just remove the
+                    // last byte from proper headers chain.
+                    const properHeaders = data.sweepProof.bitcoinHeaders.toString();
+                    data.sweepProof.bitcoinHeaders = properHeaders.substring(0, properHeaders.length - 2);
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Invalid length of the headers chain");
+                });
+            });
+            context("when headers chain is not valid", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Bitcoin headers must form a chain to pass the proof validation.
+                    // That means the `previous block hash` encoded in the given block
+                    // header must match the actual previous header's hash. To test
+                    // that scenario, we corrupt the `previous block hash` of the
+                    // second header. Each header is 80 bytes length. First 4 bytes
+                    // of each header is `version` and 32 subsequent bytes is
+                    // `previous block hash`. Changing byte 85 of the whole chain will
+                    // do the work.
+                    const properHeaders = data.sweepProof.bitcoinHeaders.toString();
+                    data.sweepProof.bitcoinHeaders = `${properHeaders.substring(0, 170)}ff${properHeaders.substring(172)}`;
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Invalid headers chain");
+                });
+            });
+            context("when the work in the header is insufficient", () => {
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithoutMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    // Each header encodes a `difficulty target` field in bytes 72-76.
+                    // The given header's hash (interpreted as uint) must be bigger than
+                    // the `difficulty target`. To test this scenario, we change the
+                    // last byte of the last header in such a way their hash becomes
+                    // lower than their `difficulty target`.
+                    const properHeaders = data.sweepProof.bitcoinHeaders.toString();
+                    data.sweepProof.bitcoinHeaders = `${properHeaders.substring(0, properHeaders.length - 2)}ff`;
+                    await (0, chai_1.expect)(runMovedFundsSweepScenario(data)).to.be.revertedWith("Insufficient work in a header");
+                });
+            });
+            context("when accumulated difficulty in headers chain is insufficient", () => {
+                let otherBridge;
+                const data = JSON.parse(JSON.stringify(moving_funds_1.MovedFundsSweepWithMainUtxo));
+                before(async () => {
+                    await createSnapshot();
+                    // Necessary to pass the first part of proof validation.
+                    relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                    relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                    // Deploy another bridge which has higher `txProofDifficultyFactor`
+                    // than the original bridge. That means it will need 12 confirmations
+                    // to deem transaction proof validity. This scenario uses test
+                    // data which has only 6 confirmations. That should force the
+                    // failure we expect within this scenario.
+                    otherBridge = await BridgeFactory.deploy();
+                    await otherBridge.initialize(bank.address, relay.address, treasury.address, walletRegistry.address, 12);
+                    await otherBridge.deployed();
+                });
+                after(async () => {
+                    relay.getCurrentEpochDifficulty.reset();
+                    relay.getPrevEpochDifficulty.reset();
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(otherBridge.submitMovedFundsSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo)).to.be.revertedWith("Insufficient accumulated difficulty in header chain");
+                });
+            });
+        });
+    });
+    describe("notifyMovedFundsSweepTimeout", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        const walletMembersIDs = [1, 2, 3, 4, 5];
+        // Just an arbitrary request for test purposes.
+        const movedFundsSweepRequest = {
+            walletPubKeyHash: ecdsa_1.ecdsaWalletTestData.pubKeyHash160,
+            txHash: "0x7d5f7d4ae705d6adb8a402e5cd7f25f839a3f3ed243a8961c8ac5887d5aaf528",
+            txOutputIndex: 1,
+            txOutputValue: 1747020,
+        };
+        context("when moved funds sweep request is in the Pending state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletDraft);
+                await bridge.setPendingMovedFundsSweepRequest(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when moved funds sweep request has timed out", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await increaseTime(movedFundsSweepTimeout);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                context("when the wallet is either in the Live or MovingFunds state", () => {
+                    const testData = [
+                        {
+                            testName: "when the wallet is in the Live state but the wallet is not the active one",
+                            walletState: fixtures_1.walletState.Live,
+                            additionalSetup: async () => {
+                                // The active wallet is a different wallet than the tested one
+                                await bridge.setActiveWallet("0x0b9f85c224b0e018a5865392927b3f9e16cf5e79");
+                            },
+                            additionalAssertions: async () => {
+                                it("should decrease the live wallets count", async () => {
+                                    (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                                });
+                                it("should not unset the active wallet", async () => {
+                                    (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.not.equal("0x0000000000000000000000000000000000000000");
+                                });
+                            },
+                        },
+                        {
+                            testName: "when the wallet is in the Live state and the wallet is the active one",
+                            walletState: fixtures_1.walletState.Live,
+                            additionalSetup: async () => {
+                                await bridge.setActiveWallet(movedFundsSweepRequest.walletPubKeyHash);
+                            },
+                            additionalAssertions: async () => {
+                                it("should decrease the live wallets count", async () => {
+                                    (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                                });
+                                it("should unset the active wallet", async () => {
+                                    (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal("0x0000000000000000000000000000000000000000");
+                                });
+                            },
+                        },
+                        {
+                            testName: "when the wallet is in the MovingFunds state",
+                            walletState: fixtures_1.walletState.MovingFunds,
+                            additionalSetup: async () => { },
+                            additionalAssertions: async () => { },
+                        },
+                    ];
+                    testData.forEach((test) => {
+                        context(test.testName, async () => {
+                            let tx;
+                            before(async () => {
+                                await createSnapshot();
+                                // We change the wallet state while preserving other fields.
+                                // We don't have an update function in the stub so we just use
+                                // the getter to get wallet fields and set them through the
+                                // setter with state field overwritten.
+                                await bridge.setWallet(movedFundsSweepRequest.walletPubKeyHash, {
+                                    ...(await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash)),
+                                    state: test.walletState,
+                                });
+                                await test.additionalSetup();
+                                tx = await bridge
+                                    .connect(thirdParty)
+                                    .notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs);
+                            });
+                            after(async () => {
+                                walletRegistry.closeWallet.reset();
+                                walletRegistry.seize.reset();
+                                await restoreSnapshot();
+                            });
+                            it("should switch the moved funds sweep request to the TimedOut state", async () => {
+                                const requestKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                    movedFundsSweepRequest.txHash,
+                                    movedFundsSweepRequest.txOutputIndex,
+                                ]);
+                                (0, chai_1.expect)((await bridge.movedFundsSweepRequests(requestKey)).state).to.be.equal(fixtures_1.movedFundsSweepRequestState.TimedOut);
+                            });
+                            it("should decrease the number of pending moved funds sweep requests for the given wallet", async () => (0, chai_1.expect)((await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash)).pendingMovedFundsSweepRequestsCount).to.be.equal(0));
+                            it("should switch the wallet to Terminated state", async () => {
+                                (0, chai_1.expect)((await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash)).state).to.be.equal(fixtures_1.walletState.Terminated);
+                            });
+                            it("should emit WalletTerminated event", async () => {
+                                await (0, chai_1.expect)(tx)
+                                    .to.emit(bridge, "WalletTerminated")
+                                    .withArgs(walletDraft.ecdsaWalletID, movedFundsSweepRequest.walletPubKeyHash);
+                            });
+                            it("should call ECDSA Wallet Registry's closeWallet function", async () => {
+                                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                                (0, chai_1.expect)(walletRegistry.closeWallet).to.have.been.calledOnceWith(walletDraft.ecdsaWalletID);
+                            });
+                            it("should call the ECDSA wallet registry's seize function", async () => {
+                                (0, chai_1.expect)(walletRegistry.seize).to.have.been.calledOnceWith(movedFundsSweepTimeoutSlashingAmount, movedFundsSweepTimeoutNotifierRewardMultiplier, await thirdParty.getAddress(), walletDraft.ecdsaWalletID, walletMembersIDs);
+                            });
+                            it("should emit MovedFundsSweepTimedOut event", async () => {
+                                await (0, chai_1.expect)(tx)
+                                    .to.emit(bridge, "MovedFundsSweepTimedOut")
+                                    .withArgs(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex);
+                            });
+                            await test.additionalAssertions();
+                        });
+                    });
+                });
+                context("when the wallet is in the Terminated state", () => {
+                    let tx;
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(movedFundsSweepRequest.walletPubKeyHash, {
+                            ...(await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash)),
+                            state: fixtures_1.walletState.Terminated,
+                        });
+                        tx = await bridge
+                            .connect(thirdParty)
+                            .notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should switch the moved funds sweep request to the TimedOut state", async () => {
+                        const requestKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                            movedFundsSweepRequest.txHash,
+                            movedFundsSweepRequest.txOutputIndex,
+                        ]);
+                        (0, chai_1.expect)((await bridge.movedFundsSweepRequests(requestKey)).state).to.be.equal(fixtures_1.movedFundsSweepRequestState.TimedOut);
+                    });
+                    it("should decrease the number of pending moved funds sweep requests for the given wallet", async () => (0, chai_1.expect)((await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash))
+                        .pendingMovedFundsSweepRequestsCount).to.be.equal(0));
+                    it("should not change the wallet state", async () => {
+                        (0, chai_1.expect)((await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash))
+                            .state).to.be.equal(fixtures_1.walletState.Terminated);
+                    });
+                });
+                context("when the wallet is neither in the Live nor MovingFunds nor Terminated state", () => {
+                    const testData = [
+                        {
+                            testName: "when the wallet is in the Unknown state",
+                            walletState: fixtures_1.walletState.Unknown,
+                        },
+                        {
+                            testName: "when the wallet is in the Closing state",
+                            walletState: fixtures_1.walletState.Closing,
+                        },
+                        {
+                            testName: "when the wallet is in the Closed state",
+                            walletState: fixtures_1.walletState.Closed,
+                        },
+                    ];
+                    testData.forEach((test) => {
+                        context(test.testName, async () => {
+                            before(async () => {
+                                await createSnapshot();
+                                await bridge.setWallet(movedFundsSweepRequest.walletPubKeyHash, {
+                                    ...(await bridge.wallets(movedFundsSweepRequest.walletPubKeyHash)),
+                                    state: test.walletState,
+                                });
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(bridge.notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs)).to.be.revertedWith("Wallet must be in Live or MovingFunds or Terminated state");
+                            });
+                        });
+                    });
+                });
+            });
+            context("when moved funds sweep request has not timed out yet", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await increaseTime(movedFundsSweepTimeout - 1);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs)).to.be.revertedWith("Sweep request has not timed out yet");
+                });
+            });
+        });
+        context("when moved funds sweep request is not in the Pending state", () => {
+            context("when moved funds sweep request is in the Unknown state", () => {
+                before(async () => {
+                    await createSnapshot();
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs)).to.be.revertedWith("Sweep request must be in Pending state");
+                });
+            });
+            context("when moved funds sweep request is in the Processed state", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletDraft);
+                    await bridge.setPendingMovedFundsSweepRequest(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest);
+                    await bridge.processPendingMovedFundsSweepRequest(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs)).to.be.revertedWith("Sweep request must be in Pending state");
+                });
+            });
+            context("when moved funds sweep request is in the TimedOut state", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletDraft);
+                    await bridge.setPendingMovedFundsSweepRequest(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest);
+                    await bridge.timeoutPendingMovedFundsSweepRequest(movedFundsSweepRequest.walletPubKeyHash, movedFundsSweepRequest);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyMovedFundsSweepTimeout(movedFundsSweepRequest.txHash, movedFundsSweepRequest.txOutputIndex, walletMembersIDs)).to.be.revertedWith("Sweep request must be in Pending state");
+                });
+            });
+        });
+    });
+    async function runMovingFundsScenario(data, beforeProofActions) {
+        relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+        relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+        // Simulate the wallet is a registered one.
+        await bridge.setWallet(data.wallet.pubKeyHash, {
+            ecdsaWalletID: data.wallet.ecdsaWalletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: await lastBlockTime(),
+            movingFundsRequestedAt: await lastBlockTime(),
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: data.wallet.state,
+            movingFundsTargetWalletsCommitmentHash: data.targetWalletsCommitment.length > 0
+                ? hardhat_1.ethers.utils.solidityKeccak256(["bytes20[]"], [data.targetWalletsCommitment])
+                : hardhat_1.ethers.constants.HashZero,
+        });
+        // Simulate the prepared main UTXO belongs to the wallet.
+        await bridge.setWalletMainUtxo(data.wallet.pubKeyHash, data.mainUtxo);
+        if (beforeProofActions) {
+            await beforeProofActions();
+        }
+        const tx = await bridge.submitMovingFundsProof(data.movingFundsTx, data.movingFundsProof, data.mainUtxo, data.wallet.pubKeyHash);
+        relay.getCurrentEpochDifficulty.reset();
+        relay.getPrevEpochDifficulty.reset();
+        return tx;
+    }
+    async function runMovedFundsSweepScenario(data, beforeProofActions) {
+        relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+        relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+        // Simulate the wallet is a registered one.
+        await bridge.setWallet(data.wallet.pubKeyHash, {
+            ecdsaWalletID: data.wallet.ecdsaWalletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: await lastBlockTime(),
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: data.wallet.state,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        });
+        if (data.mainUtxo.txHash !== hardhat_1.ethers.constants.HashZero) {
+            // Simulate the prepared main UTXO belongs to the wallet.
+            await bridge.setWalletMainUtxo(data.wallet.pubKeyHash, data.mainUtxo);
+        }
+        if (data.movedFundsSweepRequest) {
+            await bridge.setPendingMovedFundsSweepRequest(data.movedFundsSweepRequest.walletPubKeyHash, data.movedFundsSweepRequest);
+            // Just make sure the stub function `setPendingMovedFundsSweepRequest`
+            // initialized the counter properly.
+            (0, chai_1.assert)((await bridge.wallets(data.movedFundsSweepRequest.walletPubKeyHash))
+                .pendingMovedFundsSweepRequestsCount === 1, "Pending moved funds request counter for the sweeping wallet should be set up to 1");
+        }
+        if (beforeProofActions) {
+            await beforeProofActions();
+        }
+        const tx = await bridge.submitMovedFundsSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo);
+        relay.getCurrentEpochDifficulty.reset();
+        relay.getPrevEpochDifficulty.reset();
+        return tx;
+    }
+});