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

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

@@ -0,0 +1,1834 @@
+"use strict";
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+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 });
+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 deposit_sweep_1 = require("../data/deposit-sweep");
+chai_1.default.use(smock_1.smock.matchers);
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const { lastBlockTime } = hardhat_1.helpers.time;
+const ZERO_ADDRESS = hardhat_1.ethers.constants.AddressZero;
+describe("Bridge - Deposit", () => {
+    let governance;
+    let treasury;
+    let bank;
+    let relay;
+    let BridgeFactory;
+    let bridge;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ governance, treasury, bank, relay, BridgeFactory, bridge } =
+            await hardhat_1.waffle.loadFixture(bridge_1.default));
+        // Set the deposit dust threshold to 0.0001 BTC, i.e. 100x smaller than
+        // the initial value in the Bridge in order to save test Bitcoins.
+        await bridge.setDepositDustThreshold(10000);
+    });
+    describe("revealDeposit", () => {
+        // Data of a proper P2SH deposit funding transaction. Little-endian hash is:
+        // 0x17350f81cdb61cd8d7014ad1507d4af8d032b75812cf88d2c636c1c022991af2 and
+        // this is the same as `expectedP2SHDeposit.transaction` mentioned in
+        // tbtc-ts/test/deposit.test.ts file.
+        const P2SHFundingTx = {
+            version: "0x01000000",
+            inputVector: "0x018348cdeb551134fe1f19d378a8adec9b146671cb67b945b71bf56b20d" +
+                "c2b952f0100000000ffffffff",
+            outputVector: "0x02102700000000000017a9142c1444d23936c57bdd8b3e67e5938a5440c" +
+                "da455877ed73b00000000001600147ac2d9378a1c47e589dfb8095ca95ed2" +
+                "140d2726",
+            locktime: "0x00000000",
+        };
+        // Data of a proper P2WSH deposit funding transaction. Little-endian hash is:
+        // 0x6a81de17ce3da1eadc833c5fd9d85dac307d3b78235f57afbcd9f068fc01b99e and
+        // this is the same as `expectedP2WSHDeposit.transaction` mentioned in
+        // tbtc-ts/test/deposit.test.ts file.
+        const P2WSHFundingTx = {
+            version: "0x01000000",
+            inputVector: "0x018348cdeb551134fe1f19d378a8adec9b146671cb67b945b71bf56b20d" +
+                "c2b952f0100000000ffffffff",
+            outputVector: "0x021027000000000000220020df74a2e385542c87acfafa564ea4bc4fc4e" +
+                "b87d2b6a37d6c3b64722be83c636f10d73b00000000001600147ac2d9378a" +
+                "1c47e589dfb8095ca95ed2140d2726",
+            locktime: "0x00000000",
+        };
+        // Data matching the redeem script locking the funding output of
+        // P2SHFundingTx and P2WSHFundingTx.
+        const reveal = {
+            fundingOutputIndex: 0,
+            depositor: "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637",
+            blindingFactor: "0xf9f0c90d00039523",
+            // HASH160 of 03989d253b17a6a0f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d9.
+            walletPubKeyHash: "0x8db50eb52063ea9d98b3eac91489a90f738986f6",
+            // HASH160 of 0300d6f28a2f6bf9836f57fcda5d284c9a8f849316119779f0d6090830d97763a9.
+            refundPubKeyHash: "0x28e081f285138ccbe389c1eb8985716230129f89",
+            refundLocktime: "0x60bcea61",
+            vault: "0x594cfd89700040163727828AE20B52099C58F02C",
+        };
+        context("when wallet is in Live state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.connect(governance).setVaultStatus(reveal.vault, true);
+                // Simulate the wallet is a Live one and is known in the system.
+                await bridge.setWallet(reveal.walletPubKeyHash, {
+                    ecdsaWalletID: hardhat_1.ethers.constants.HashZero,
+                    mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                    pendingRedemptionsValue: 0,
+                    createdAt: await lastBlockTime(),
+                    movingFundsRequestedAt: 0,
+                    closingStartedAt: 0,
+                    pendingMovedFundsSweepRequestsCount: 0,
+                    state: fixtures_1.walletState.Live,
+                    movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when funding transaction is P2SH", () => {
+                context("when funding output script hash is correct", () => {
+                    context("when deposit was not revealed yet", () => {
+                        context("when amount is not below the dust threshold", () => {
+                            context("when deposit is routed to a trusted vault", () => {
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    tx = await bridge.revealDeposit(P2SHFundingTx, reveal);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should store proper deposit data", async () => {
+                                    // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                    const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                        "0x17350f81cdb61cd8d7014ad1507d4af8d032b75812cf88d2c636c1c022991af2",
+                                        reveal.fundingOutputIndex,
+                                    ]);
+                                    const deposit = await bridge.deposits(depositKey);
+                                    // Depositor address, same as in `reveal.depositor`.
+                                    (0, chai_1.expect)(deposit.depositor).to.be.equal("0x934B98637cA318a4D6E7CA6ffd1690b8e77df637");
+                                    // Deposit amount in satoshi. In this case it's 10000 satoshi
+                                    // because the P2SH deposit transaction set this value for the
+                                    // funding output.
+                                    (0, chai_1.expect)(deposit.amount).to.be.equal(10000);
+                                    // Revealed time should be set.
+                                    (0, chai_1.expect)(deposit.revealedAt).to.be.equal(await lastBlockTime());
+                                    // Deposit vault, same as in `reveal.vault`.
+                                    (0, chai_1.expect)(deposit.vault).to.be.equal("0x594cfd89700040163727828AE20B52099C58F02C");
+                                    // Treasury fee should be computed according to the current
+                                    // value of the `depositTreasuryFeeDivisor`.
+                                    (0, chai_1.expect)(deposit.treasuryFee).to.be.equal(5);
+                                    // Swept time should be unset.
+                                    (0, chai_1.expect)(deposit.sweptAt).to.be.equal(0);
+                                });
+                                it("should emit DepositRevealed event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "DepositRevealed")
+                                        .withArgs("0x17350f81cdb61cd8d7014ad1507d4af8d032b75812cf88d2c636c1c022991af2", reveal.fundingOutputIndex, "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637", 10000, "0xf9f0c90d00039523", "0x8db50eb52063ea9d98b3eac91489a90f738986f6", "0x28e081f285138ccbe389c1eb8985716230129f89", "0x60bcea61", reveal.vault);
+                                });
+                            });
+                            context("when deposit is not routed to a vault", () => {
+                                let tx;
+                                let nonRoutedReveal;
+                                before(async () => {
+                                    await createSnapshot();
+                                    nonRoutedReveal = { ...reveal };
+                                    nonRoutedReveal.vault = ZERO_ADDRESS;
+                                    tx = await bridge.revealDeposit(P2SHFundingTx, nonRoutedReveal);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should accept the deposit", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "DepositRevealed")
+                                        .withArgs("0x17350f81cdb61cd8d7014ad1507d4af8d032b75812cf88d2c636c1c022991af2", reveal.fundingOutputIndex, "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637", 10000, "0xf9f0c90d00039523", "0x8db50eb52063ea9d98b3eac91489a90f738986f6", "0x28e081f285138ccbe389c1eb8985716230129f89", "0x60bcea61", ZERO_ADDRESS);
+                                });
+                            });
+                            context("when deposit is routed to a non-trusted vault", () => {
+                                let nonTrustedVaultReveal;
+                                before(async () => {
+                                    await createSnapshot();
+                                    nonTrustedVaultReveal = { ...reveal };
+                                    nonTrustedVaultReveal.vault =
+                                        "0x92499afEAD6c41f757Ec3558D0f84bf7ec5aD967";
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge.revealDeposit(P2SHFundingTx, nonTrustedVaultReveal)).to.be.revertedWith("Vault is not trusted");
+                                });
+                            });
+                        });
+                        context("when amount is below the dust threshold", () => {
+                            before(async () => {
+                                await createSnapshot();
+                                // The `P2SHFundingTx` used within this scenario has an output
+                                // whose value is 10000 satoshi. To make the scenario happen, it
+                                // is enough that the contract's deposit dust threshold is
+                                // bigger by 1 satoshi.
+                                await bridge.setDepositDustThreshold(10001);
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(bridge.revealDeposit(P2SHFundingTx, reveal)).to.be.revertedWith("Deposit amount too small");
+                            });
+                        });
+                    });
+                    context("when deposit was already revealed", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.revealDeposit(P2SHFundingTx, reveal);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.revealDeposit(P2SHFundingTx, reveal)).to.be.revertedWith("Deposit already revealed");
+                        });
+                    });
+                });
+                context("when funding output script hash is wrong", () => {
+                    it("should revert", async () => {
+                        // Corrupt reveal data by setting a wrong depositor address.
+                        const corruptedReveal = { ...reveal };
+                        corruptedReveal.depositor =
+                            "0x24CbaB95C69e5bcbE328252F957A39d906eE75f3";
+                        await (0, chai_1.expect)(bridge.revealDeposit(P2SHFundingTx, corruptedReveal)).to.be.revertedWith("Wrong 20-byte script hash");
+                    });
+                });
+            });
+            context("when funding transaction is P2WSH", () => {
+                context("when funding output script hash is correct", () => {
+                    context("when deposit was not revealed yet", () => {
+                        context("when deposit is routed to a trusted vault", () => {
+                            let tx;
+                            before(async () => {
+                                await createSnapshot();
+                                tx = await bridge.revealDeposit(P2WSHFundingTx, reveal);
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should store proper deposit data", async () => {
+                                // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                    "0x6a81de17ce3da1eadc833c5fd9d85dac307d3b78235f57afbcd9f068fc01b99e",
+                                    reveal.fundingOutputIndex,
+                                ]);
+                                const deposit = await bridge.deposits(depositKey);
+                                // Depositor address, same as in `reveal.depositor`.
+                                (0, chai_1.expect)(deposit.depositor).to.be.equal("0x934B98637cA318a4D6E7CA6ffd1690b8e77df637");
+                                // Deposit amount in satoshi. In this case it's 10000 satoshi
+                                // because the P2SH deposit transaction set this value for the
+                                // funding output.
+                                (0, chai_1.expect)(deposit.amount).to.be.equal(10000);
+                                // Revealed time should be set.
+                                (0, chai_1.expect)(deposit.revealedAt).to.be.equal(await lastBlockTime());
+                                // Deposit vault, same as in `reveal.vault`.
+                                (0, chai_1.expect)(deposit.vault).to.be.equal("0x594cfd89700040163727828AE20B52099C58F02C");
+                                // Treasury fee should be computed according to the current
+                                // value of the `depositTreasuryFeeDivisor`.
+                                (0, chai_1.expect)(deposit.treasuryFee).to.be.equal(5);
+                                // Swept time should be unset.
+                                (0, chai_1.expect)(deposit.sweptAt).to.be.equal(0);
+                            });
+                            it("should emit DepositRevealed event", async () => {
+                                await (0, chai_1.expect)(tx)
+                                    .to.emit(bridge, "DepositRevealed")
+                                    .withArgs("0x6a81de17ce3da1eadc833c5fd9d85dac307d3b78235f57afbcd9f068fc01b99e", reveal.fundingOutputIndex, "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637", 10000, "0xf9f0c90d00039523", "0x8db50eb52063ea9d98b3eac91489a90f738986f6", "0x28e081f285138ccbe389c1eb8985716230129f89", "0x60bcea61", reveal.vault);
+                            });
+                        });
+                        context("when deposit is not routed to a vault", () => {
+                            let tx;
+                            let nonRoutedReveal;
+                            before(async () => {
+                                await createSnapshot();
+                                nonRoutedReveal = { ...reveal };
+                                nonRoutedReveal.vault = ZERO_ADDRESS;
+                                tx = await bridge.revealDeposit(P2WSHFundingTx, nonRoutedReveal);
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should accept the deposit", async () => {
+                                await (0, chai_1.expect)(tx)
+                                    .to.emit(bridge, "DepositRevealed")
+                                    .withArgs("0x6a81de17ce3da1eadc833c5fd9d85dac307d3b78235f57afbcd9f068fc01b99e", reveal.fundingOutputIndex, "0x934B98637cA318a4D6E7CA6ffd1690b8e77df637", 10000, "0xf9f0c90d00039523", "0x8db50eb52063ea9d98b3eac91489a90f738986f6", "0x28e081f285138ccbe389c1eb8985716230129f89", "0x60bcea61", ZERO_ADDRESS);
+                            });
+                        });
+                        context("when deposit is routed to a non-trusted vault", () => {
+                            let nonTrustedVaultReveal;
+                            before(async () => {
+                                await createSnapshot();
+                                nonTrustedVaultReveal = { ...reveal };
+                                nonTrustedVaultReveal.vault =
+                                    "0x92499afEAD6c41f757Ec3558D0f84bf7ec5aD967";
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(bridge.revealDeposit(P2WSHFundingTx, nonTrustedVaultReveal)).to.be.revertedWith("Vault is not trusted");
+                            });
+                        });
+                    });
+                    context("when deposit was already revealed", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.revealDeposit(P2WSHFundingTx, reveal);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.revealDeposit(P2WSHFundingTx, reveal)).to.be.revertedWith("Deposit already revealed");
+                        });
+                    });
+                });
+                context("when funding output script hash is wrong", () => {
+                    it("should revert", async () => {
+                        // Corrupt reveal data by setting a wrong depositor address.
+                        const corruptedReveal = { ...reveal };
+                        corruptedReveal.depositor =
+                            "0x24CbaB95C69e5bcbE328252F957A39d906eE75f3";
+                        await (0, chai_1.expect)(bridge.revealDeposit(P2WSHFundingTx, corruptedReveal)).to.be.revertedWith("Wrong 32-byte script hash");
+                    });
+                });
+            });
+            context("when funding transaction is neither P2SH nor P2WSH", () => {
+                it("should revert", async () => {
+                    // Corrupt transaction output data by making a 21-byte script hash.
+                    const corruptedP2SHFundingTx = { ...P2SHFundingTx };
+                    corruptedP2SHFundingTx.outputVector =
+                        "0x02102700000000000017a9156a6ade1c799a3e5a59678e776f21be14d66dc" +
+                            "15ed8877ed73b00000000001600147ac2d9378a1c47e589dfb8095ca95ed2" +
+                            "140d2726";
+                    await (0, chai_1.expect)(bridge.revealDeposit(corruptedP2SHFundingTx, reveal)).to.be.revertedWith("Wrong script hash length");
+                });
+            });
+        });
+        context("when wallet is not in Live state", () => {
+            const testData = [
+                {
+                    testName: "when wallet state is Unknown",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when wallet state is MovingFunds",
+                    walletState: fixtures_1.walletState.MovingFunds,
+                },
+                {
+                    testName: "when the source wallet is in the Closing state",
+                    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(reveal.walletPubKeyHash, {
+                            ecdsaWalletID: hardhat_1.ethers.constants.HashZero,
+                            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                            pendingRedemptionsValue: 0,
+                            createdAt: await lastBlockTime(),
+                            movingFundsRequestedAt: 0,
+                            closingStartedAt: 0,
+                            pendingMovedFundsSweepRequestsCount: 0,
+                            state: test.walletState,
+                            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.revealDeposit(P2SHFundingTx, reveal)).to.be.revertedWith("Wallet must be in Live state");
+                    });
+                });
+            });
+        });
+    });
+    describe("submitDepositSweepProof", () => {
+        const walletDraft = {
+            ecdsaWalletID: hardhat_1.ethers.constants.HashZero,
+            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 state is Live", () => {
+            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 main UTXO data are valid", () => {
+                                context("when transaction fee does not exceed the deposit transaction maximum fee", () => {
+                                    context("when there is only one input", () => {
+                                        context("when the single input is a revealed unswept P2SH deposit", () => {
+                                            let tx;
+                                            const data = deposit_sweep_1.SingleP2SHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                tx = await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposit as swept", async () => {
+                                                // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.deposits[0].fundingTx.hash,
+                                                    data.deposits[0].reveal.fundingOutputIndex,
+                                                ]);
+                                                const deposit = await bridge.deposits(depositKey);
+                                                (0, chai_1.expect)(deposit.sweptAt).to.be.equal(await lastBlockTime());
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 20000 satoshi (from the single deposit) and there is a
+                                                // fee of 1500 so the output value is 18500.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 18500]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositor's balance", async () => {
+                                                // The sum of sweep tx inputs is 20000 satoshi. The output
+                                                // value is 18500 so the transaction fee is 1500. There is
+                                                // only one deposit so it incurs the entire transaction fee.
+                                                // The deposit should also incur the treasury fee whose
+                                                // initial value is 0.05% of the deposited amount so the
+                                                // final depositor balance should be cut by 10 satoshi.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(18490);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(10);
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when the single input is a revealed unswept P2WSH deposit", () => {
+                                            let tx;
+                                            const data = deposit_sweep_1.SingleP2WSHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                tx = await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposit as swept", async () => {
+                                                // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.deposits[0].fundingTx.hash,
+                                                    data.deposits[0].reveal.fundingOutputIndex,
+                                                ]);
+                                                const deposit = await bridge.deposits(depositKey);
+                                                (0, chai_1.expect)(deposit.sweptAt).to.be.equal(await lastBlockTime());
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 80000 satoshi (from the single deposit) and there is a
+                                                // fee of 2000 so the output value is 78000.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 78000]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositor's balance", async () => {
+                                                // The sum of sweep tx inputs is 80000 satoshi. The output
+                                                // value is 78000 so the fee is 2000. There is only one
+                                                // deposit so it incurs the entire fee. The deposit should
+                                                // also incur the treasury fee whose initial value is 0.05%
+                                                // of the deposited amount so the final depositor balance
+                                                // should be cut by 40 satoshi.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(77960);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(40);
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when the single input is a revealed unswept deposit with a trusted vault", async () => {
+                                            let vault;
+                                            let tx;
+                                            const data = deposit_sweep_1.SingleP2WSHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Deploy a fake vault and mark it as trusted.
+                                                vault = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vault.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = vault.address;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vault.address;
+                                                tx = await runDepositSweepScenario(dataWithVault);
+                                            });
+                                            after(async () => {
+                                                vault.receiveBalanceIncrease.reset();
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposit as swept", async () => {
+                                                // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.deposits[0].fundingTx.hash,
+                                                    data.deposits[0].reveal.fundingOutputIndex,
+                                                ]);
+                                                const deposit = await bridge.deposits(depositKey);
+                                                (0, chai_1.expect)(deposit.sweptAt).to.be.equal(await lastBlockTime());
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 80000 satoshi (from the single deposit) and there is a
+                                                // fee of 2000 so the output value is 78000.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 78000]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should not update the depositor's balance", async () => {
+                                                // The depositor balance should not be increased.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(0);
+                                            });
+                                            it("should update the vault's balance", async () => {
+                                                // The vault's balance should be increased by the
+                                                // sum of all swept deposits counted as follows:
+                                                //
+                                                // The sum of sweep tx inputs is 80000 satoshi. The output
+                                                // value is 78000 so the fee is 2000. There is only one
+                                                // deposit so it incurs the entire fee. The deposit should
+                                                // also incur the treasury fee whose initial value is 0.05%
+                                                // of the deposited amount so the final depositor balance
+                                                // should be cut by 40 satoshi. The final sum
+                                                // is 77960.
+                                                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.be.equal(77960);
+                                            });
+                                            it("should call the vault's receiveBalanceIncrease function", async () => {
+                                                (0, chai_1.expect)(vault.receiveBalanceIncrease).to.have.been.calledOnceWith([data.deposits[0].reveal.depositor], [77960]);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(40);
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when the single input is a revealed unswept deposit with a non-trusted vault", async () => {
+                                            let vault;
+                                            let tx;
+                                            const data = deposit_sweep_1.SingleP2WSHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Deploy a fake vault and mark it as trusted.
+                                                vault = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vault.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = vault.address;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vault.address;
+                                                // Mark the vault as non-trusted just before
+                                                // proof submission.
+                                                const beforeProofActions = async () => {
+                                                    await bridge
+                                                        .connect(governance)
+                                                        .setVaultStatus(vault.address, false);
+                                                };
+                                                tx = await runDepositSweepScenario(dataWithVault, beforeProofActions);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposit as swept", async () => {
+                                                // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.deposits[0].fundingTx.hash,
+                                                    data.deposits[0].reveal.fundingOutputIndex,
+                                                ]);
+                                                const deposit = await bridge.deposits(depositKey);
+                                                (0, chai_1.expect)(deposit.sweptAt).to.be.equal(await lastBlockTime());
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 80000 satoshi (from the single deposit) and there is a
+                                                // fee of 2000 so the output value is 78000.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 78000]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositor's balance", async () => {
+                                                // The sum of sweep tx inputs is 80000 satoshi. The output
+                                                // value is 78000 so the fee is 2000. There is only one
+                                                // deposit so it incurs the entire fee. The deposit should
+                                                // also incur the treasury fee whose initial value is 0.05%
+                                                // of the deposited amount so the final depositor balance
+                                                // should be cut by 40 satoshi.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(77960);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(40);
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when the single input is a revealed unswept deposit with a trusted vault but non-equal to the vault passed via function parameter", async () => {
+                                            let vault;
+                                            let tx;
+                                            const data = deposit_sweep_1.SingleP2WSHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Deploy a fake vault and mark it as trusted.
+                                                vault = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vault.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                // However, deliberately set the `vault` parameter
+                                                // passed to `submitDepositSweepProof` to another
+                                                // value than in the deposit.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = hardhat_1.ethers.constants.AddressZero;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vault.address;
+                                                tx = runDepositSweepScenario(dataWithVault);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                await (0, chai_1.expect)(tx).to.be.revertedWith("Deposit should be routed to another vault");
+                                            });
+                                        });
+                                        context("when the single input is the expected main UTXO", () => {
+                                            const previousData = deposit_sweep_1.SingleP2SHDeposit;
+                                            const data = deposit_sweep_1.SingleMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = previousData.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep which is actually the predecessor
+                                                // of the sweep tested within this scenario.
+                                                await runDepositSweepScenario(previousData);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Sweep transaction must process at least one deposit");
+                                            });
+                                        });
+                                        context("when the single input is a revealed but already swept deposit", () => {
+                                            const data = deposit_sweep_1.SingleP2SHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make a proper sweep to turn the tested deposit into
+                                                // the swept state.
+                                                await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                // Main UTXO parameter must point to the properly
+                                                // made sweep to avoid revert at validation stage.
+                                                const mainUtxo = {
+                                                    txHash: data.sweepTx.hash,
+                                                    txOutputIndex: 0,
+                                                    txOutputValue: 18500,
+                                                };
+                                                // Try replaying the already done sweep.
+                                                await (0, chai_1.expect)(bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, mainUtxo, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Deposit already swept");
+                                            });
+                                        });
+                                        context("when the single input is an unknown", () => {
+                                            const data = deposit_sweep_1.SingleP2SHDeposit;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Necessary to pass the proof validation.
+                                                relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                                                relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                // Try to sweep a deposit which was not revealed before and
+                                                // is unknown from system's point of view.
+                                                await (0, chai_1.expect)(bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, deposit_sweep_1.NO_MAIN_UTXO, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Unknown input type");
+                                            });
+                                        });
+                                    });
+                                    // Since P2SH vs P2WSH path has been already checked in the scenario
+                                    // "when there is only one input", we no longer differentiate deposits
+                                    // using that criterion during "when there are multiple inputs" scenario.
+                                    context("when there are multiple inputs", () => {
+                                        context("when input vector consists only of revealed unswept deposits and the expected main UTXO", () => {
+                                            let tx;
+                                            const previousData = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            const data = deposit_sweep_1.MultipleDepositsWithMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep which is actually the predecessor
+                                                // of the sweep tested within this scenario.
+                                                await runDepositSweepScenario(previousData);
+                                                tx = await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposits as swept", async () => {
+                                                for (let i = 0; i < data.deposits.length; i++) {
+                                                    // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                    const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.deposits[i].fundingTx.hash,
+                                                        data.deposits[i].reveal.fundingOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    const deposit = await bridge.deposits(depositKey);
+                                                    (0, chai_1.expect)(deposit.sweptAt).to.be.equal(
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    await lastBlockTime(), `Deposit with index ${i} has an unexpected swept time`);
+                                                }
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 4148000 satoshi and there is a fee of 2999 so the output
+                                                // value is 4145001.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 4145001]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositors balances", async () => {
+                                                // The sum of sweep tx inputs is 4148000 satoshi. The output
+                                                // value is 4145001 so the sweep transaction fee is 2999.
+                                                // There are 5 deposits so the fee per deposit is 599
+                                                // and the indivisible remainder is 4 which means the
+                                                // last deposit should incur 603 satoshi. Worth noting
+                                                // the order of deposits used by this test scenario
+                                                // data does not correspond to the order of sweep
+                                                // transaction inputs. Each deposit should also incur
+                                                // the treasury fee whose initial value is 0.05% of the
+                                                // deposited amount.
+                                                // Deposit with index 0 used as input with index 5
+                                                // in the sweep transaction. This is the last deposit
+                                                // (according to inputs order) and it should incur the
+                                                // remainder of the transaction fee.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(219287);
+                                                // Deposit with index 1 used as input with index 3
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[1].reveal.depositor)).to.be.equal(759021);
+                                                // Deposit with index 2 used as input with index 1
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[2].reveal.depositor)).to.be.equal(938931);
+                                                // Deposit with index 3 used as input with index 2
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[3].reveal.depositor)).to.be.equal(878961);
+                                                // Deposit with index 4 used as input with index 4
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[4].reveal.depositor)).to.be.equal(289256);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(2075);
+                                            });
+                                            it("should mark the previous main UTXO as spent", async () => {
+                                                const mainUtxoKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.mainUtxo.txHash,
+                                                    data.mainUtxo.txOutputIndex,
+                                                ]);
+                                                (0, chai_1.expect)(await bridge.spentMainUTXOs(mainUtxoKey)).to
+                                                    .be.true;
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when input vector consists only of revealed unswept deposits with a trusted vault and the expected main UTXO", () => {
+                                            let vault;
+                                            let tx;
+                                            const previousData = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            const data = deposit_sweep_1.MultipleDepositsWithMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep which is actually the predecessor
+                                                // of the sweep tested within this scenario.
+                                                await runDepositSweepScenario(previousData);
+                                                // Deploy a fake vault and mark it as trusted.
+                                                vault = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vault.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = vault.address;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[1].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[2].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[3].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[4].reveal.vault =
+                                                    vault.address;
+                                                tx = await runDepositSweepScenario(dataWithVault);
+                                            });
+                                            after(async () => {
+                                                vault.receiveBalanceIncrease.reset();
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposits as swept", async () => {
+                                                for (let i = 0; i < data.deposits.length; i++) {
+                                                    // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                    const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.deposits[i].fundingTx.hash,
+                                                        data.deposits[i].reveal.fundingOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    const deposit = await bridge.deposits(depositKey);
+                                                    (0, chai_1.expect)(deposit.sweptAt).to.be.equal(
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    await lastBlockTime(), `Deposit with index ${i} has an unexpected swept time`);
+                                                }
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 4148000 satoshi and there is a fee of 2999 so the output
+                                                // value is 4145001.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 4145001]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should not update the depositors balances", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(0);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[1].reveal.depositor)).to.be.equal(0);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[2].reveal.depositor)).to.be.equal(0);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[3].reveal.depositor)).to.be.equal(0);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[4].reveal.depositor)).to.be.equal(0);
+                                            });
+                                            it("should update the vault's balance", async () => {
+                                                // The vault's balance should be increased by the
+                                                // sum of all swept deposits counted as follows:
+                                                //
+                                                // The sum of sweep tx inputs is 4148000 satoshi
+                                                // (including the main UTXO value). The output value
+                                                // is 4145001 so the sweep transaction fee is 2999.
+                                                // There are 5 deposits so the fee per deposit is 599
+                                                // and the indivisible remainder is 4 which means the
+                                                // last deposit should incur 603 satoshi. Each deposit
+                                                // should also incur the treasury fee whose initial
+                                                // value is 0.05% of the deposited amount. The
+                                                // final sum of all deposits is 3085456.
+                                                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.be.equal(3085456);
+                                            });
+                                            it("should call the vault's receiveBalanceIncrease function", async () => {
+                                                // The order of deposits is different that
+                                                // the order of inputs that refers them in
+                                                // the transaction.
+                                                (0, chai_1.expect)(vault.receiveBalanceIncrease).to.have.been.calledOnceWith([
+                                                    data.deposits[2].reveal.depositor,
+                                                    data.deposits[3].reveal.depositor,
+                                                    data.deposits[1].reveal.depositor,
+                                                    data.deposits[4].reveal.depositor,
+                                                    data.deposits[0].reveal.depositor,
+                                                ], [938931, 878961, 759021, 289256, 219287]);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(2075);
+                                            });
+                                            it("should mark the previous main UTXO as spent", async () => {
+                                                const mainUtxoKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.mainUtxo.txHash,
+                                                    data.mainUtxo.txOutputIndex,
+                                                ]);
+                                                (0, chai_1.expect)(await bridge.spentMainUTXOs(mainUtxoKey)).to
+                                                    .be.true;
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when input vector consists only of revealed unswept deposits with a non-trusted vault and the expected main UTXO", () => {
+                                            let vault;
+                                            let tx;
+                                            const previousData = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            const data = deposit_sweep_1.MultipleDepositsWithMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep which is actually the predecessor
+                                                // of the sweep tested within this scenario.
+                                                await runDepositSweepScenario(previousData);
+                                                // Deploy a fake vault and mark it as trusted.
+                                                vault = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vault.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = vault.address;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[1].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[2].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[3].reveal.vault =
+                                                    vault.address;
+                                                dataWithVault.deposits[4].reveal.vault =
+                                                    vault.address;
+                                                // Mark the vault as non-trusted just before
+                                                // proof submission.
+                                                const beforeProofActions = async () => {
+                                                    await bridge
+                                                        .connect(governance)
+                                                        .setVaultStatus(vault.address, false);
+                                                };
+                                                tx = await runDepositSweepScenario(dataWithVault, beforeProofActions);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposits as swept", async () => {
+                                                for (let i = 0; i < data.deposits.length; i++) {
+                                                    // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                    const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.deposits[i].fundingTx.hash,
+                                                        data.deposits[i].reveal.fundingOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    const deposit = await bridge.deposits(depositKey);
+                                                    (0, chai_1.expect)(deposit.sweptAt).to.be.equal(
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    await lastBlockTime(), `Deposit with index ${i} has an unexpected swept time`);
+                                                }
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 4148000 satoshi and there is a fee of 2999 so the output
+                                                // value is 4145001.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 4145001]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositors balances", async () => {
+                                                // The sum of sweep tx inputs is 4148000 satoshi. The output
+                                                // value is 4145001 so the sweep transaction fee is 2999.
+                                                // There are 5 deposits so the fee per deposit is 599
+                                                // and the indivisible remainder is 4 which means the
+                                                // last deposit should incur 603 satoshi. Worth noting
+                                                // the order of deposits used by this test scenario
+                                                // data does not correspond to the order of sweep
+                                                // transaction inputs. Each deposit should also incur
+                                                // the treasury fee whose initial value is 0.05% of the
+                                                // deposited amount.
+                                                // Deposit with index 0 used as input with index 5
+                                                // in the sweep transaction. This is the last deposit
+                                                // (according to inputs order) and it should incur the
+                                                // remainder of the transaction fee.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(219287);
+                                                // Deposit with index 1 used as input with index 3
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[1].reveal.depositor)).to.be.equal(759021);
+                                                // Deposit with index 2 used as input with index 1
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[2].reveal.depositor)).to.be.equal(938931);
+                                                // Deposit with index 3 used as input with index 2
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[3].reveal.depositor)).to.be.equal(878961);
+                                                // Deposit with index 4 used as input with index 4
+                                                // in the sweep transaction.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[4].reveal.depositor)).to.be.equal(289256);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(2075);
+                                            });
+                                            it("should mark the previous main UTXO as spent", async () => {
+                                                const mainUtxoKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                    data.mainUtxo.txHash,
+                                                    data.mainUtxo.txOutputIndex,
+                                                ]);
+                                                (0, chai_1.expect)(await bridge.spentMainUTXOs(mainUtxoKey)).to
+                                                    .be.true;
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when input vector consists only of revealed unswept deposits with different trusted vaults and the expected main UTXO", () => {
+                                            let vaultA;
+                                            let vaultB;
+                                            let tx;
+                                            const previousData = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            const data = deposit_sweep_1.MultipleDepositsWithMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep which is actually the predecessor
+                                                // of the sweep tested within this scenario.
+                                                await runDepositSweepScenario(previousData);
+                                                // Deploy two fake vaults and mark them as trusted.
+                                                vaultA = await smock_1.smock.fake("IVault");
+                                                vaultB = await smock_1.smock.fake("IVault");
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vaultA.address, true);
+                                                await bridge
+                                                    .connect(governance)
+                                                    .setVaultStatus(vaultB.address, true);
+                                                // Enrich the test data with the vault parameter.
+                                                const dataWithVault = JSON.parse(JSON.stringify(data));
+                                                dataWithVault.vault = vaultA.address;
+                                                dataWithVault.deposits[0].reveal.vault =
+                                                    vaultA.address;
+                                                dataWithVault.deposits[1].reveal.vault =
+                                                    vaultA.address;
+                                                dataWithVault.deposits[2].reveal.vault =
+                                                    vaultB.address;
+                                                dataWithVault.deposits[3].reveal.vault =
+                                                    vaultB.address;
+                                                dataWithVault.deposits[4].reveal.vault =
+                                                    vaultA.address;
+                                                tx = runDepositSweepScenario(dataWithVault);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                await (0, chai_1.expect)(tx).to.be.revertedWith("Deposit should be routed to another vault");
+                                            });
+                                        });
+                                        context("when input vector consists only of revealed unswept deposits but there is no main UTXO since it is not expected", () => {
+                                            let tx;
+                                            const data = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                tx = await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should mark deposits as swept", async () => {
+                                                for (let i = 0; i < data.deposits.length; i++) {
+                                                    // Deposit key is keccak256(fundingTxHash | fundingOutputIndex).
+                                                    const depositKey = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32"], [
+                                                        data.deposits[i].fundingTx.hash,
+                                                        data.deposits[i].reveal.fundingOutputIndex,
+                                                    ]);
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    const deposit = await bridge.deposits(depositKey);
+                                                    (0, chai_1.expect)(deposit.sweptAt).to.be.equal(
+                                                    // eslint-disable-next-line no-await-in-loop
+                                                    await lastBlockTime(), `Deposit with index ${i} has an unexpected swept time`);
+                                                }
+                                            });
+                                            it("should update main UTXO for the given wallet", async () => {
+                                                const { mainUtxoHash } = await bridge.wallets(walletPubKeyHash);
+                                                // Amount can be checked by opening the sweep tx in a Bitcoin
+                                                // testnet explorer. In this case, the sum of inputs is
+                                                // 1060000 satoshi and there is a fee of 2000 so the output
+                                                // value is 1058000.
+                                                const expectedMainUtxo = hardhat_1.ethers.utils.solidityKeccak256(["bytes32", "uint32", "uint64"], [data.sweepTx.hash, 0, 1058000]);
+                                                (0, chai_1.expect)(mainUtxoHash).to.be.equal(expectedMainUtxo);
+                                            });
+                                            it("should update the depositors balances", async () => {
+                                                // The sum of sweep tx inputs is 1060000 satoshi. The output
+                                                // value is 1058000 so the sweep transaction fee is 2000.
+                                                // There are 5 deposits so the fee per deposit is 400
+                                                // and there is no indivisible remainder. Each deposit
+                                                // should also incur the treasury fee whose initial
+                                                // value is 0.05% of the deposited amount.
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[0].reveal.depositor)).to.be.equal(29585);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[1].reveal.depositor)).to.be.equal(9595);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[2].reveal.depositor)).to.be.equal(209495);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[3].reveal.depositor)).to.be.equal(369415);
+                                                (0, chai_1.expect)(await bank.balanceOf(data.deposits[4].reveal.depositor)).to.be.equal(439380);
+                                            });
+                                            it("should transfer collected treasury fee", async () => {
+                                                (0, chai_1.expect)(await bank.balanceOf(treasury.address)).to.be.equal(530);
+                                            });
+                                            it("should emit DepositsSwept event", async () => {
+                                                await (0, chai_1.expect)(tx)
+                                                    .to.emit(bridge, "DepositsSwept")
+                                                    .withArgs(walletPubKeyHash, data.sweepTx.hash);
+                                            });
+                                        });
+                                        context("when input vector consists only of revealed unswept deposits but there is no main UTXO despite it is expected", () => {
+                                            const previousData = deposit_sweep_1.SingleP2WSHDeposit;
+                                            const data = JSON.parse(JSON.stringify(deposit_sweep_1.MultipleDepositsNoMainUtxo));
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = previousData.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make the first sweep to create an on-chain expectation
+                                                // that the tested sweep will contain the main UTXO
+                                                // input.
+                                                await runDepositSweepScenario(previousData);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                // Use sweep data which doesn't reference the main UTXO.
+                                                // However, pass a correct main UTXO parameter in order
+                                                // to pass main UTXO validation in the contract.
+                                                data.mainUtxo = {
+                                                    txHash: previousData.sweepTx.hash,
+                                                    txOutputIndex: 0,
+                                                    txOutputValue: 78000,
+                                                };
+                                                await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Expected main UTXO not present in sweep transaction inputs");
+                                            });
+                                        });
+                                        context("when input vector contains a revealed but already swept deposit", () => {
+                                            const data = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                                // Make a proper sweep to turn the tested deposits into
+                                                // the swept state.
+                                                await runDepositSweepScenario(data);
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                // Main UTXO parameter must point to the properly
+                                                // made sweep to avoid revert at validation stage.
+                                                const mainUtxo = {
+                                                    txHash: data.sweepTx.hash,
+                                                    txOutputIndex: 0,
+                                                    txOutputValue: 1058000,
+                                                };
+                                                // Try replaying the already done sweep.
+                                                await (0, chai_1.expect)(bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, mainUtxo, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Deposit already swept");
+                                            });
+                                        });
+                                        context("when input vector contains an unknown input", () => {
+                                            const data = deposit_sweep_1.MultipleDepositsWithMainUtxo;
+                                            // Take wallet public key hash from first deposit. All
+                                            // deposits in same sweep batch should have the same value
+                                            // of that field.
+                                            const { walletPubKeyHash } = data.deposits[0].reveal;
+                                            before(async () => {
+                                                await createSnapshot();
+                                                // Simulate the wallet is a Live one and is known in
+                                                // the system.
+                                                await bridge.setWallet(walletPubKeyHash, {
+                                                    ...walletDraft,
+                                                    state: fixtures_1.walletState.Live,
+                                                });
+                                            });
+                                            after(async () => {
+                                                await restoreSnapshot();
+                                            });
+                                            it("should revert", async () => {
+                                                // Used test data contains an actual main UTXO input
+                                                // but the previous action proof was not submitted on-chain
+                                                // so input is unknown from contract's perspective.
+                                                await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Unknown input type");
+                                            });
+                                        });
+                                    });
+                                });
+                                context("when transaction fee exceeds the deposit transaction maximum fee", () => {
+                                    const data = deposit_sweep_1.SingleP2SHDeposit;
+                                    // Take wallet public key hash from first deposit. All
+                                    // deposits in same sweep batch should have the same value
+                                    // of that field.
+                                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        // Simulate the wallet is a Live one and is known in
+                                        // the system.
+                                        await bridge.setWallet(walletPubKeyHash, {
+                                            ...walletDraft,
+                                            state: fixtures_1.walletState.Live,
+                                        });
+                                        // Set the deposit transaction maximum fee to a value much
+                                        // lower than the fee used by the test data transaction.
+                                        await bridge.setDepositTxMaxFee(100);
+                                    });
+                                    after(async () => {
+                                        await restoreSnapshot();
+                                    });
+                                    it("should revert", async () => {
+                                        await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("'Transaction fee is too high");
+                                    });
+                                });
+                            });
+                            context("when main UTXO data are invalid", () => {
+                                const previousData = deposit_sweep_1.MultipleDepositsNoMainUtxo;
+                                const data = JSON.parse(JSON.stringify(deposit_sweep_1.MultipleDepositsWithMainUtxo));
+                                // Take wallet public key hash from first deposit. All
+                                // deposits in same sweep batch should have the same value
+                                // of that field.
+                                const { walletPubKeyHash } = data.deposits[0].reveal;
+                                before(async () => {
+                                    await createSnapshot();
+                                    // Simulate the wallet is a Live one and is known in
+                                    // the system.
+                                    await bridge.setWallet(walletPubKeyHash, {
+                                        ...walletDraft,
+                                        state: fixtures_1.walletState.Live,
+                                    });
+                                    // Make the first sweep which is actually the predecessor
+                                    // of the sweep tested within this scenario.
+                                    await runDepositSweepScenario(previousData);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    // Forge the main UTXO parameter to force validation crash.
+                                    data.mainUtxo = deposit_sweep_1.NO_MAIN_UTXO;
+                                    await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Invalid main UTXO data");
+                                });
+                            });
+                        });
+                        context("when single output is neither P2PKH nor P2WPKH", () => {
+                            const data = deposit_sweep_1.SingleMainUtxoP2SHOutput;
+                            before(async () => {
+                                await createSnapshot();
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Output must be P2PKH or P2WPKH");
+                            });
+                        });
+                    });
+                    context("when the single output is not 20-byte", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            // Necessary to pass the proof validation.
+                            relay.getPrevEpochDifficulty.returns(20870012);
+                            relay.getCurrentEpochDifficulty.returns(20870012);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            // To test this case, an arbitrary transaction with single
+                            // P2WSH output is used. In that case, the wallet public key
+                            // hash will have a wrong length of 32 bytes. Used transaction:
+                            // https://live.blockcypher.com/btc-testnet/tx/af56cae479215c5e44a6a4db0eeb10a1abdd98020a6c01b9c26ea7b829aa2809
+                            const sweepTx = {
+                                version: "0x01000000",
+                                inputVector: "0x01d32586237f6a832c3aa324bb83151e43e6cca2e4312d676f14" +
+                                    "dbbd6b1f04f4680100000000ffffffff",
+                                outputVector: "0x012ea3090000000000220020af802a76c10b6a646fff8d358241" +
+                                    "c121c9be1c53628adb26bd6554631bfc7d8b",
+                                locktime: "0x00000000",
+                            };
+                            const sweepProof = {
+                                merkleProof: "0xf09955dcfb05b1c369eb9f58b6e583e49f47b9b8d6e63537dcac" +
+                                    "10bf0cc5407d06e76ee2d75b5be5ec365a4c1272067b786d79a64d" +
+                                    "c015eb40dedd3c813f4dee40c149ee21036bba713d14b3c22454ef" +
+                                    "44c958293a015e9e186983f20c46d74a29ca5f705913e210229078" +
+                                    "af993e89d90bb731dab3c8cf8907d683ab60faca1866036118737e" +
+                                    "07aaa74d489e80f773b4d9ff2887a4855b805aaf1b5a7a1b0bf382" +
+                                    "be8dab2401ec758a705b648724f93d14c3b72ce4fb3cd7d414e8a1" +
+                                    "75ef173e",
+                                txIndexInBlock: 20,
+                                bitcoinHeaders: "0x0000e020fbeb3a876746438f1fd793add061b0b7af2f88a387ee" +
+                                    "f5b38600000000000000933a0cec98a028727df04dafbbe691c8ad" +
+                                    "442351db7321c9f7cc169aa9f64a9a7af6f361cbcd001a65073028",
+                            };
+                            await (0, chai_1.expect)(bridge.submitDepositSweepProof(sweepTx, sweepProof, deposit_sweep_1.NO_MAIN_UTXO, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Output's public key hash must have 20 bytes");
+                        });
+                    });
+                });
+                context("when output count is other than one", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        // Necessary to pass the proof validation.
+                        relay.getCurrentEpochDifficulty.returns(1);
+                        relay.getPrevEpochDifficulty.returns(1);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        // To test this case, an arbitrary transaction with two
+                        // outputs is used. Used transaction:
+                        // https://live.blockcypher.com/btc-testnet/tx/af56cae479215c5e44a6a4db0eeb10a1abdd98020a6c01b9c26ea7b829aa2809
+                        const sweepTx = {
+                            version: "0x01000000",
+                            inputVector: "0x011d9b71144a3ddbb56dd099ee94e6dd8646d7d1eb37fe1195367e6f" +
+                                "a844a388e7010000006a47304402206f8553c07bcdc0c3b90631188810" +
+                                "3d623ca9096ca0b28b7d04650a029a01fcf9022064cda02e39e65ace71" +
+                                "2029845cfcf58d1b59617d753c3fd3556f3551b609bbb00121039d61d6" +
+                                "2dcd048d3f8550d22eb90b4af908db60231d117aeede04e7bc11907bfa" +
+                                "ffffffff",
+                            outputVector: "0x02204e00000000000017a9143ec459d0f3c29286ae5df5fcc421e278" +
+                                "6024277e87a6c2140000000000160014e257eccafbc07c381642ce6e7e" +
+                                "55120fb077fbed",
+                            locktime: "0x00000000",
+                        };
+                        const sweepProof = {
+                            merkleProof: "0x161d24e53fc61db783f0271d45ef43b76e69fc975cf38decbba654ae" +
+                                "3d09f5d1a060c3448c0c06ededa9749e559ffa65e2d5f3abac749b278e" +
+                                "1189aa5b49a499b032963ea3fad337c4a9c8df4e748865503b5aea083f" +
+                                "b32efe4dca057a741a020790cde5b50acc2cdbd231e43594036388f1e5" +
+                                "d20ebba319465c56e85bf4e4b4f8b7276402b6c114000c59149494f852" +
+                                "84507c253bbc505fec7ea50f370aa150",
+                            txIndexInBlock: 8,
+                            bitcoinHeaders: "0x00000020fbee5222c9fc99c8071cee3fed39b4c0d39f41075469ce9f" +
+                                "52000000000000003fd9c72d0611b373ce2b1996e0ebb8bc36dc12d431" +
+                                "cae5b9371f343111f3d7519015da61ffff001dbddfb528000040208a9f" +
+                                "e49585b4cd8a94daeeb926c6f1e96151c74ae1ae0b18c6a6d564000000" +
+                                "0065c05d9ea40cace1b6b0ad0b8a9a18646096b54484fbdd96b1596560" +
+                                "f6999194a815da612ac0001a2e4c6405",
+                        };
+                        await (0, chai_1.expect)(bridge.submitDepositSweepProof(sweepTx, sweepProof, deposit_sweep_1.NO_MAIN_UTXO, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("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(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    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.sweepTx.inputVector =
+                            "0x0079544f374199c68869ce7df906eeb0ee5c0506a512d903e3900d5752" +
+                                "e3e080c500000000c847304402205eff3ae003a5903eb33f32737e3442b6" +
+                                "516685a1addb19339c2d02d400cf67ce0220707435fc2a0577373c63c99d" +
+                                "242c30bea5959ec180169978d43ece50618fe0ff012103989d253b17a6a0" +
+                                "f41838b84ff0d20e8898f9d7b1a98f2564da4cc29dcf8581d94c5c14934b" +
+                                "98637ca318a4d6e7ca6ffd1690b8e77df6377508f9f0c90d000395237576" +
+                                "a9148db50eb52063ea9d98b3eac91489a90f738986f68763ac6776a914e2" +
+                                "57eccafbc07c381642ce6e7e55120fb077fbed8804e0250162b175ac68ff" +
+                                "ffffff";
+                        await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Invalid input vector provided");
+                    });
+                });
+                context("when output vector is not valid", () => {
+                    const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    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 =
+                            "0x0044480000000000001600148db50eb52063ea9d98b3eac91489a90f73" +
+                                "8986f6";
+                        await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Invalid output vector provided");
+                    });
+                });
+                context("when merkle proof is not valid", () => {
+                    const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    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 36 so any other will do the trick.
+                        data.sweepProof.txIndexInBlock = 30;
+                        await (0, chai_1.expect)(runDepositSweepScenario(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(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        // To pass the proof validation, the difficulty returned by the relay
+                        // must be 22350181 for test data used in this scenario. Setting
+                        // a different value will cause difficulty comparison failure.
+                        data.chainDifficulty = 1;
+                        await (0, chai_1.expect)(runDepositSweepScenario(data)).to.be.revertedWith("Not at current or previous difficulty");
+                    });
+                });
+                context("when headers chain length is not valid", () => {
+                    const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        // Corrupt the bitcoin headers length in the sweep 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)(runDepositSweepScenario(data)).to.be.revertedWith("Invalid length of the headers chain");
+                    });
+                });
+                context("when headers chain is not valid", () => {
+                    const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    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)(runDepositSweepScenario(data)).to.be.revertedWith("Invalid headers chain");
+                    });
+                });
+                context("when the work in the header is insufficient", () => {
+                    const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                    });
+                    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)(runDepositSweepScenario(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(deposit_sweep_1.SingleP2SHDeposit));
+                    // Take wallet public key hash from first deposit. All
+                    // deposits in same sweep batch should have the same value
+                    // of that field.
+                    const { walletPubKeyHash } = data.deposits[0].reveal;
+                    before(async () => {
+                        await createSnapshot();
+                        // Simulate the wallet is a Live one and is known in
+                        // the system.
+                        await bridge.setWallet(walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                        // 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, hardhat_1.ethers.utils.hexZeroPad("0x01", 20), 12);
+                        await otherBridge.deployed();
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(otherBridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Insufficient accumulated difficulty in header chain");
+                    });
+                });
+            });
+        });
+        context("when the wallet state is MovingFunds", () => {
+            // The execution of `submitDepositSweepProof` is the same for wallets in
+            // `MovingFunds` state as for the ones in `Live` state. Therefore the
+            // testing of `MovingFunds` state is limited to just one simple test case
+            // (sweeping single P2SH deposit).
+            const data = deposit_sweep_1.SingleP2SHDeposit;
+            const { fundingTx, reveal } = data.deposits[0];
+            before(async () => {
+                await createSnapshot();
+                // Initially set the state to Live, so that the deposit can be revealed
+                await bridge.setWallet(reveal.walletPubKeyHash, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.Live,
+                });
+                relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                await bridge.revealDeposit(fundingTx, reveal);
+                // Simulate the wallet's state has changed to MovingFunds
+                const wallet = await bridge.wallets(reveal.walletPubKeyHash);
+                await bridge.setWallet(reveal.walletPubKeyHash, {
+                    ...wallet,
+                    state: fixtures_1.walletState.MovingFunds,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should succeed", async () => {
+                await (0, chai_1.expect)(bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo, hardhat_1.ethers.constants.AddressZero)).not.to.be.reverted;
+            });
+        });
+        context("when the wallet state is neither Live or MovingFunds", () => {
+            const data = deposit_sweep_1.SingleP2SHDeposit;
+            const { fundingTx, reveal } = data.deposits[0];
+            const testData = [
+                {
+                    testName: "when wallet state is Unknown",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    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();
+                        // Initially set the state to Live, so that the deposit can be revealed
+                        await bridge.setWallet(reveal.walletPubKeyHash, {
+                            ...walletDraft,
+                            state: fixtures_1.walletState.Live,
+                        });
+                        relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                        relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                        await bridge.revealDeposit(fundingTx, reveal);
+                        // Simulate the wallet's state has changed
+                        const wallet = await bridge.wallets(reveal.walletPubKeyHash);
+                        await bridge.setWallet(reveal.walletPubKeyHash, {
+                            ...wallet,
+                            state: test.walletState,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo, hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Wallet must be in Live or MovingFunds state");
+                    });
+                });
+            });
+        });
+    });
+    async function runDepositSweepScenario(data, beforeProofActions) {
+        relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+        relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+        for (let i = 0; i < data.deposits.length; i++) {
+            const { fundingTx, reveal } = data.deposits[i];
+            // eslint-disable-next-line no-await-in-loop
+            await bridge.revealDeposit(fundingTx, reveal);
+        }
+        if (beforeProofActions) {
+            await beforeProofActions();
+        }
+        return bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo, data.vault);
+    }
+});