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

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

@@ -0,0 +1,1017 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-underscore-dangle */
+const hardhat_1 = require("hardhat");
+const chai_1 = __importStar(require("chai"));
+const smock_1 = require("@defi-wonderland/smock");
+const deposit_sweep_1 = require("../data/deposit-sweep");
+const ecdsa_1 = require("../data/ecdsa");
+const fixtures_1 = require("../fixtures");
+const bridge_1 = __importDefault(require("../fixtures/bridge"));
+chai_1.default.use(smock_1.smock.matchers);
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const { lastBlockTime, increaseTime } = hardhat_1.helpers.time;
+describe("Bridge - Wallets", () => {
+    let thirdParty;
+    let walletRegistry;
+    let bridge;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ thirdParty, walletRegistry, bridge } = await hardhat_1.waffle.loadFixture(bridge_1.default));
+    });
+    describe("requestNewWallet", () => {
+        before(async () => {
+            await createSnapshot();
+        });
+        after(async () => {
+            walletRegistry.requestNewWallet.reset();
+            await restoreSnapshot();
+        });
+        context("when called by a third party", async () => {
+            context("when wallet creation is not in progress", () => {
+                before(async () => {
+                    await createSnapshot();
+                    walletRegistry.getWalletCreationState.returns(fixtures_1.ecdsaDkgState.IDLE);
+                });
+                after(async () => {
+                    walletRegistry.getWalletCreationState.reset();
+                    await restoreSnapshot();
+                });
+                context("when active wallet is not set", () => {
+                    let tx;
+                    before(async () => {
+                        await createSnapshot();
+                        tx = await bridge.connect(thirdParty).requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO);
+                    });
+                    after(async () => {
+                        walletRegistry.requestNewWallet.reset();
+                        await restoreSnapshot();
+                    });
+                    it("should emit NewWalletRequested event", async () => {
+                        await (0, chai_1.expect)(tx).to.emit(bridge, "NewWalletRequested");
+                    });
+                    it("should call ECDSA Wallet Registry's requestNewWallet function", async () => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                        (0, chai_1.expect)(walletRegistry.requestNewWallet).to.have.been.calledOnce;
+                    });
+                });
+                context("when active wallet is set", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setActiveWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                            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 active wallet has a main UTXO set", () => {
+                        context("when the active wallet main UTXO data are valid", () => {
+                            context("when wallet creation conditions are met", () => {
+                                context("when active wallet is old enough and its balance is greater or equal the minimum BTC balance threshold", () => {
+                                    let tx;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        // Make the wallet old enough.
+                                        await increaseTime(fixtures_1.constants.walletCreationPeriod);
+                                        // Simulate the wallet has a BTC balance equal to the
+                                        // minimum BTC amount threshold by preparing the wallet's
+                                        // main UTXO accordingly.
+                                        const activeWalletMainUtxo = {
+                                            txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                            txOutputIndex: 1,
+                                            txOutputValue: fixtures_1.constants.walletCreationMinBtcBalance,
+                                        };
+                                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, activeWalletMainUtxo);
+                                        tx = await bridge.requestNewWallet(activeWalletMainUtxo);
+                                    });
+                                    after(async () => {
+                                        walletRegistry.requestNewWallet.reset();
+                                        await restoreSnapshot();
+                                    });
+                                    it("should emit NewWalletRequested event", async () => {
+                                        await (0, chai_1.expect)(tx).to.emit(bridge, "NewWalletRequested");
+                                    });
+                                    it("should call ECDSA Wallet Registry's requestNewWallet function", async () => {
+                                        await (0, chai_1.expect)(walletRegistry.requestNewWallet).to.have.been
+                                            .calledOnce;
+                                    });
+                                });
+                                context("when active wallet is not old enough but its balance is greater or equal the maximum BTC balance threshold", () => {
+                                    let tx;
+                                    before(async () => {
+                                        await createSnapshot();
+                                        // Simulate the wallet has a BTC balance equal to the
+                                        // maximum BTC amount threshold by preparing the wallet's
+                                        // main UTXO accordingly. Note that the time is not
+                                        // increased at all so the wallet is not old enough
+                                        // for sure.
+                                        const activeWalletMainUtxo = {
+                                            txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                            txOutputIndex: 1,
+                                            txOutputValue: fixtures_1.constants.walletCreationMaxBtcBalance,
+                                        };
+                                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, activeWalletMainUtxo);
+                                        tx = await bridge.requestNewWallet(activeWalletMainUtxo);
+                                    });
+                                    after(async () => {
+                                        walletRegistry.requestNewWallet.reset();
+                                        await restoreSnapshot();
+                                    });
+                                    it("should emit NewWalletRequested event", async () => {
+                                        await (0, chai_1.expect)(tx).to.emit(bridge, "NewWalletRequested");
+                                    });
+                                    it("should call ECDSA Wallet Registry's requestNewWallet function", async () => {
+                                        await (0, chai_1.expect)(walletRegistry.requestNewWallet).to.have.been
+                                            .calledOnce;
+                                    });
+                                });
+                            });
+                            context("when active wallet is not old enough and its balance is greater or equal the minimum but lesser than the maximum BTC balance threshold", () => {
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    // Simulate the wallet has a BTC balance between the minimum
+                                    // and maximum BTC amount thresholds by preparing the
+                                    // wallet's main UTXO accordingly. Note that the time is not
+                                    // increased at all so the wallet is not old enough for sure.
+                                    const activeWalletMainUtxo = {
+                                        txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                        txOutputIndex: 1,
+                                        txOutputValue: fixtures_1.constants.walletCreationMaxBtcBalance.sub(1),
+                                    };
+                                    await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, activeWalletMainUtxo);
+                                    tx = bridge.requestNewWallet(activeWalletMainUtxo);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(tx).to.be.revertedWith("Wallet creation conditions are not met");
+                                });
+                            });
+                            context("when active wallet is old enough but its balance is lesser than the minimum BTC balance threshold", () => {
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    // Make the wallet old enough.
+                                    await increaseTime(fixtures_1.constants.walletCreationPeriod);
+                                    // Simulate the wallet has a BTC balance below the minimum
+                                    // BTC amount threshold by preparing the wallet's main
+                                    // UTXO accordingly.
+                                    const activeWalletMainUtxo = {
+                                        txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                        txOutputIndex: 1,
+                                        txOutputValue: fixtures_1.constants.walletCreationMinBtcBalance.sub(1),
+                                    };
+                                    await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, activeWalletMainUtxo);
+                                    tx = bridge.requestNewWallet(activeWalletMainUtxo);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(tx).to.be.revertedWith("Wallet creation conditions are not met");
+                                });
+                            });
+                        });
+                        context("when the active wallet main UTXO data are invalid", () => {
+                            const activeWalletMainUtxo = {
+                                txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                                txOutputIndex: 1,
+                                txOutputValue: fixtures_1.constants.walletCreationMaxBtcBalance,
+                            };
+                            before(async () => {
+                                await createSnapshot();
+                                await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, activeWalletMainUtxo);
+                            });
+                            after(async () => {
+                                await restoreSnapshot();
+                            });
+                            it("should revert", async () => {
+                                const corruptedActiveWalletMainUtxo = {
+                                    ...activeWalletMainUtxo,
+                                    txOutputIndex: 0,
+                                };
+                                await (0, chai_1.expect)(bridge.requestNewWallet(corruptedActiveWalletMainUtxo)).to.be.revertedWith("Invalid wallet main UTXO data");
+                            });
+                        });
+                    });
+                    context("when active wallet has no main UTXO set", () => {
+                        before(async () => {
+                            await createSnapshot();
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        // If the wallet has 0 BTC, the function must revert.
+                        // This is because the active wallet's balance must be above the
+                        // minimum BTC balance threshold and that threshold is guaranteed
+                        // to be always greater than zero.
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO)).to.be.revertedWith("Wallet creation conditions are not met");
+                        });
+                    });
+                });
+            });
+            context("when wallet creation is already in progress", () => {
+                const testData = [
+                    {
+                        testName: "when wallet creation state is AWAITING_SEED",
+                        walletCreationState: fixtures_1.ecdsaDkgState.AWAITING_SEED,
+                    },
+                    {
+                        testName: "when wallet creation state is AWAITING_RESULT",
+                        walletCreationState: fixtures_1.ecdsaDkgState.AWAITING_RESULT,
+                    },
+                    {
+                        testName: "when wallet creation state is CHALLENGE",
+                        walletCreationState: fixtures_1.ecdsaDkgState.CHALLENGE,
+                    },
+                ];
+                testData.forEach((test) => {
+                    context(test.testName, () => {
+                        before(async () => {
+                            await createSnapshot();
+                            walletRegistry.getWalletCreationState.returns(test.walletCreationState);
+                        });
+                        after(async () => {
+                            walletRegistry.getWalletCreationState.reset();
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge.requestNewWallet(deposit_sweep_1.NO_MAIN_UTXO)).to.be.revertedWith("Wallet creation already in progress");
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe("__ecdsaWalletCreatedCallback", () => {
+        context("when called by a third party", async () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .__ecdsaWalletCreatedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY)).to.be.revertedWith("Caller is not the ECDSA Wallet Registry");
+            });
+        });
+        context("when called by the ECDSA Wallet Registry", async () => {
+            context("when called with a valid ECDSA Wallet details", async () => {
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(walletRegistry.wallet)
+                        .__ecdsaWalletCreatedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should register ECDSA wallet reference", async () => {
+                    (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160))
+                        .ecdsaWalletID).equals(ecdsa_1.ecdsaWalletTestData.walletID);
+                });
+                it("should transition wallet to Live state", async () => {
+                    (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).state).equals(fixtures_1.walletState.Live);
+                });
+                it("should set the created at timestamp", async () => {
+                    (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).createdAt).equals(await lastBlockTime());
+                });
+                it("should set the wallet as the active one", async () => {
+                    (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).equals(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+                it("should emit NewWalletRegistered event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "NewWalletRegistered")
+                        .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+                it("should increase the live wallets counter", async () => {
+                    (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(1);
+                });
+            });
+            context("when called with the ECDSA Wallet already registered", async () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge
+                        .connect(walletRegistry.wallet)
+                        .__ecdsaWalletCreatedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                const testData = [
+                    {
+                        testName: "with unique wallet ID and unique public key",
+                        walletID: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyX: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyY: hardhat_1.ethers.utils.randomBytes(32),
+                        expectedError: undefined,
+                    },
+                    {
+                        testName: "with duplicated wallet ID and unique public key",
+                        walletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                        publicKeyX: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyY: hardhat_1.ethers.utils.randomBytes(32),
+                        expectedError: undefined,
+                    },
+                    {
+                        testName: "with unique wallet ID, unique public key X and duplicated public key Y",
+                        walletID: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyX: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyY: ecdsa_1.ecdsaWalletTestData.publicKeyY,
+                        expectedError: undefined,
+                    },
+                    {
+                        testName: "with unique wallet ID, unique public key Y and duplicated public key X",
+                        walletID: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyX: ecdsa_1.ecdsaWalletTestData.publicKeyY,
+                        publicKeyY: hardhat_1.ethers.utils.randomBytes(32),
+                        expectedError: undefined,
+                    },
+                    {
+                        testName: "with unique wallet ID and duplicated public key",
+                        walletID: hardhat_1.ethers.utils.randomBytes(32),
+                        publicKeyX: ecdsa_1.ecdsaWalletTestData.publicKeyX,
+                        publicKeyY: ecdsa_1.ecdsaWalletTestData.publicKeyY,
+                        expectedError: "ECDSA wallet has been already registered",
+                    },
+                    {
+                        testName: "with duplicated wallet ID and duplicated public key",
+                        walletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                        publicKeyX: ecdsa_1.ecdsaWalletTestData.publicKeyX,
+                        publicKeyY: ecdsa_1.ecdsaWalletTestData.publicKeyY,
+                        expectedError: "ECDSA wallet has been already registered",
+                    },
+                ];
+                testData.forEach((test) => {
+                    context(test.testName, async () => {
+                        beforeEach(async () => {
+                            await createSnapshot();
+                        });
+                        afterEach(async () => {
+                            await restoreSnapshot();
+                        });
+                        it(test.expectedError ? "should revert" : "should not revert", async () => {
+                            const tx = bridge
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletCreatedCallback(test.walletID, test.publicKeyX, test.publicKeyY);
+                            if (test.expectedError) {
+                                await (0, chai_1.expect)(tx).to.be.revertedWith(test.expectedError);
+                            }
+                            else {
+                                await (0, chai_1.expect)(tx).not.to.be.reverted;
+                            }
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe("__ecdsaWalletHeartbeatFailedCallback", () => {
+        context("when called by the ECDSA Wallet Registry", () => {
+            context("when wallet is in Live state", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                        ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                        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 wallet balance is zero", () => {
+                    context("when wallet is the active one", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the tested wallet as the active one.
+                            await bridge.setActiveWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to Closing", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.Closing);
+                        });
+                        it("should set the wallet's closing started timestamp", async () => {
+                            const wallet = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(wallet.closingStartedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletClosing event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletClosing")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should unset the active wallet", async () => {
+                            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal("0x0000000000000000000000000000000000000000");
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                    context("when wallet is not the active one", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the active wallet to be different than the tested one.
+                            await bridge.setActiveWallet(hardhat_1.ethers.utils.ripemd160(ecdsa_1.ecdsaWalletTestData.pubKeyHash160));
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to Closing", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.Closing);
+                        });
+                        it("should set the wallet's closing started timestamp", async () => {
+                            const wallet = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(wallet.closingStartedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletClosing event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletClosing")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should not unset the active wallet", async () => {
+                            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal(hardhat_1.ethers.utils.ripemd160(ecdsa_1.ecdsaWalletTestData.pubKeyHash160));
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                });
+                context("when wallet balance is greater than zero", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                            txOutputIndex: 0,
+                            txOutputValue: 1,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    context("when wallet is the active one", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the tested wallet as the active one.
+                            await bridge.setActiveWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to MovingFunds", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                        });
+                        it("should set move funds requested at timestamp", async () => {
+                            const { movingFundsRequestedAt } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletMovingFunds event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletMovingFunds")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should unset the active wallet", async () => {
+                            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal("0x0000000000000000000000000000000000000000");
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                    context("when wallet is not the active one", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // Set the active wallet to be different than the tested one.
+                            await bridge.setActiveWallet(hardhat_1.ethers.utils.ripemd160(ecdsa_1.ecdsaWalletTestData.pubKeyHash160));
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to MovingFunds", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                        });
+                        it("should set move funds requested at timestamp", async () => {
+                            const { movingFundsRequestedAt } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletMovingFunds event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletMovingFunds")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should not unset the active wallet", async () => {
+                            (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal(hardhat_1.ethers.utils.ripemd160(ecdsa_1.ecdsaWalletTestData.pubKeyHash160));
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                });
+            });
+            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 wallet state is Closing",
+                        walletState: fixtures_1.walletState.Closing,
+                    },
+                    {
+                        testName: "when wallet state is Closed",
+                        walletState: fixtures_1.walletState.Closed,
+                    },
+                    {
+                        testName: "when wallet state is Terminated",
+                        walletState: fixtures_1.walletState.Terminated,
+                    },
+                ];
+                testData.forEach((test) => {
+                    context(test.testName, () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                                mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                                pendingRedemptionsValue: 0,
+                                createdAt: 0,
+                                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
+                                .connect(walletRegistry.wallet)
+                                .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY)).to.be.revertedWith("Wallet must be in Live state");
+                        });
+                    });
+                });
+            });
+        });
+        context("when called by a third party", () => {
+            it("should revert", async () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY)).to.be.revertedWith("Caller is not the ECDSA Wallet Registry");
+                });
+            });
+        });
+    });
+    describe("notifyWalletCloseable", () => {
+        context("when the reported wallet is not the active one", () => {
+            context("when wallet is in Live state", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                        ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                        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 wallet reached the maximum age", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await increaseTime((await bridge.walletParameters()).walletMaxAge);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    context("when wallet balance is zero", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to Closing", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.Closing);
+                        });
+                        it("should set the wallet's closing started timestamp", async () => {
+                            const wallet = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(wallet.closingStartedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletClosing event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletClosing")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                    context("when wallet balance is greater than zero", () => {
+                        const walletMainUtxo = {
+                            txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                            txOutputIndex: 0,
+                            txOutputValue: 1,
+                        };
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to MovingFunds", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                        });
+                        it("should set move funds requested at timestamp", async () => {
+                            const { movingFundsRequestedAt } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletMovingFunds event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletMovingFunds")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                });
+                context("when wallet did not reach the maximum age but their balance is lesser than the minimum threshold", () => {
+                    context("when wallet balance is zero", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to Closing", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.Closing);
+                        });
+                        it("should set the wallet's closing started timestamp", async () => {
+                            const wallet = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(wallet.closingStartedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletClosing event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletClosing")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                    context("when wallet balance is greater than zero", () => {
+                        const walletMainUtxo = {
+                            txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                            txOutputIndex: 0,
+                            txOutputValue: fixtures_1.constants.walletClosureMinBtcBalance.sub(1),
+                        };
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                            tx = await bridge
+                                .connect(walletRegistry.wallet)
+                                .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should change wallet's state to MovingFunds", async () => {
+                            const { state } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(state).to.be.equal(fixtures_1.walletState.MovingFunds);
+                        });
+                        it("should set move funds requested at timestamp", async () => {
+                            const { movingFundsRequestedAt } = await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                            (0, chai_1.expect)(movingFundsRequestedAt).to.be.equal(await lastBlockTime());
+                        });
+                        it("should emit WalletMovingFunds event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "WalletMovingFunds")
+                                .withArgs(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                        });
+                        it("should decrease the live wallets counter", async () => {
+                            (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                        });
+                    });
+                });
+                context("when wallet did not reach the maximum age and their balance is greater or equal the minimum threshold", () => {
+                    const walletMainUtxo = {
+                        txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                        txOutputIndex: 0,
+                        txOutputValue: fixtures_1.constants.walletClosureMinBtcBalance,
+                    };
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(walletRegistry.wallet)
+                            .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo)).to.be.revertedWith("Wallet needs to be old enough or have too few satoshis");
+                    });
+                });
+                context("when wallet did not reach the maximum age and invalid main UTXO data is passed", () => {
+                    const walletMainUtxo = {
+                        txHash: "0xc9e58780c6c289c25ae1fe293f85a4db4d0af4f305172f2a1868ddd917458bdf",
+                        txOutputIndex: 0,
+                        txOutputValue: fixtures_1.constants.walletClosureMinBtcBalance,
+                    };
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWalletMainUtxo(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, walletMainUtxo);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        const corruptedWalletMainUtxo = {
+                            ...walletMainUtxo,
+                            txOutputIndex: 1,
+                        };
+                        await (0, chai_1.expect)(bridge
+                            .connect(walletRegistry.wallet)
+                            .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, corruptedWalletMainUtxo)).to.be.revertedWith("Invalid wallet main UTXO data");
+                    });
+                });
+            });
+            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 wallet state is Closing",
+                        walletState: fixtures_1.walletState.Closing,
+                    },
+                    {
+                        testName: "when wallet state is Closed",
+                        walletState: fixtures_1.walletState.Closed,
+                    },
+                    {
+                        testName: "when wallet state is Terminated",
+                        walletState: fixtures_1.walletState.Terminated,
+                    },
+                ];
+                testData.forEach((test) => {
+                    context(test.testName, () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                                ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                                mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                                pendingRedemptionsValue: 0,
+                                createdAt: 0,
+                                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
+                                .connect(walletRegistry.wallet)
+                                .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO)).to.be.revertedWith("Wallet must be in Live state");
+                        });
+                    });
+                });
+            });
+        });
+        context("when the reported wallet is the active one", () => {
+            before(async () => {
+                await createSnapshot();
+                // Set the checked wallet as the active one.
+                await bridge.setActiveWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                    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();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(walletRegistry.wallet)
+                    .notifyWalletCloseable(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, deposit_sweep_1.NO_MAIN_UTXO)).to.be.revertedWith("Active wallet cannot be considered closeable");
+            });
+        });
+    });
+    describe("notifyWalletClosingPeriodElapsed", () => {
+        const walletDraft = {
+            ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+            mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+            pendingRedemptionsValue: 0,
+            createdAt: 0,
+            movingFundsRequestedAt: 0,
+            closingStartedAt: 0,
+            pendingMovedFundsSweepRequestsCount: 0,
+            state: fixtures_1.walletState.Unknown,
+            movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+        };
+        context("when the wallet is in the Closing state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                    ...walletDraft,
+                    state: fixtures_1.walletState.Live,
+                });
+                // Switches the wallet to Closing state because the wallet has
+                // no main UTXO set.
+                await bridge
+                    .connect(walletRegistry.wallet)
+                    .__ecdsaWalletHeartbeatFailedCallback(ecdsa_1.ecdsaWalletTestData.walletID, ecdsa_1.ecdsaWalletTestData.publicKeyX, ecdsa_1.ecdsaWalletTestData.publicKeyY);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when closing period has elapsed", () => {
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    await increaseTime((await bridge.walletParameters()).walletClosingPeriod);
+                    tx = await bridge.notifyWalletClosingPeriodElapsed(ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+                after(async () => {
+                    await walletRegistry.closeWallet.reset();
+                    await restoreSnapshot();
+                });
+                it("should set wallet state to Closed", async () => {
+                    (0, chai_1.expect)((await bridge.wallets(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).state).to.be.equal(fixtures_1.walletState.Closed);
+                });
+                it("should emit WalletClosed event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "WalletClosed")
+                        .withArgs(walletDraft.ecdsaWalletID, ecdsa_1.ecdsaWalletTestData.pubKeyHash160);
+                });
+                it("should call the ECDSA wallet registry's closeWallet function", async () => {
+                    (0, chai_1.expect)(walletRegistry.closeWallet).to.have.been.calledOnceWith(walletDraft.ecdsaWalletID);
+                });
+            });
+            context("when closing period has not elapsed yet", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await increaseTime((await bridge.walletParameters()).walletClosingPeriod - 1);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge.notifyWalletClosingPeriodElapsed(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Closing period has not elapsed yet");
+                });
+            });
+        });
+        context("when the wallet is not in the Closing state", () => {
+            const testData = [
+                {
+                    testName: "when wallet state is Unknown",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    testName: "when wallet state is Live",
+                    walletState: fixtures_1.walletState.Live,
+                },
+                {
+                    testName: "when wallet state is MovingFunds",
+                    walletState: fixtures_1.walletState.MovingFunds,
+                },
+                {
+                    testName: "when wallet state is Closed",
+                    walletState: fixtures_1.walletState.Closed,
+                },
+                {
+                    testName: "when wallet state is Terminated",
+                    walletState: fixtures_1.walletState.Terminated,
+                },
+            ];
+            testData.forEach((test) => {
+                context(test.testName, () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(ecdsa_1.ecdsaWalletTestData.pubKeyHash160, {
+                            ...walletDraft,
+                            state: test.walletState,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.notifyWalletClosingPeriodElapsed(ecdsa_1.ecdsaWalletTestData.pubKeyHash160)).to.be.revertedWith("Wallet must be in Closing state");
+                    });
+                });
+            });
+        });
+    });
+});