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

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

@@ -0,0 +1,1349 @@
+"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 fraud_1 = require("../data/fraud");
+const fixtures_1 = require("../fixtures");
+const bridge_1 = __importDefault(require("../fixtures/bridge"));
+const ecdsa_1 = require("../data/ecdsa");
+chai_1.default.use(smock_1.smock.matchers);
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const { lastBlockTime, increaseTime } = hardhat_1.helpers.time;
+const { keccak256, sha256 } = hardhat_1.ethers.utils;
+const { publicKey: walletPublicKey, pubKeyHash160: walletPublicKeyHash } = fraud_1.wallet;
+describe("Bridge - Fraud", () => {
+    let thirdParty;
+    let treasury;
+    let walletRegistry;
+    let bridge;
+    let fraudChallengeDepositAmount;
+    let fraudChallengeDefeatTimeout;
+    let fraudSlashingAmount;
+    let fraudNotifierRewardMultiplier;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ thirdParty, treasury, walletRegistry, bridge } =
+            await hardhat_1.waffle.loadFixture(bridge_1.default));
+        ({
+            fraudChallengeDepositAmount,
+            fraudChallengeDefeatTimeout,
+            fraudSlashingAmount,
+            fraudNotifierRewardMultiplier,
+        } = await bridge.fraudParameters());
+    });
+    describe("submitFraudChallenge", () => {
+        const data = fraud_1.witnessSignSingleInputTx;
+        context("when the wallet is in Live state", () => {
+            context("when the amount of ETH deposited is enough", () => {
+                context("when the data needed for signature verification is correct", () => {
+                    context("when the fraud challenge does not exist yet", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWallet(walletPublicKeyHash, {
+                                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,
+                            });
+                            tx = await bridge
+                                .connect(thirdParty)
+                                .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                value: fraudChallengeDepositAmount,
+                            });
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should transfer ether from the caller to the bridge", async () => {
+                            await (0, chai_1.expect)(tx).to.changeEtherBalance(thirdParty, fraudChallengeDepositAmount.mul(-1));
+                            await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount);
+                        });
+                        it("should store the fraud challenge data", async () => {
+                            const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                            const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                            (0, chai_1.expect)(fraudChallenge.challenger).to.equal(await thirdParty.getAddress());
+                            (0, chai_1.expect)(fraudChallenge.depositAmount).to.equal(fraudChallengeDepositAmount);
+                            (0, chai_1.expect)(fraudChallenge.reportedAt).to.equal(await lastBlockTime());
+                            (0, chai_1.expect)(fraudChallenge.resolved).to.equal(false);
+                        });
+                        it("should emit FraudChallengeSubmitted event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "FraudChallengeSubmitted")
+                                .withArgs(walletPublicKeyHash, data.sighash, data.signature.v, data.signature.r, data.signature.s);
+                        });
+                    });
+                    context("when the fraud challenge already exists", () => {
+                        before(async () => {
+                            await createSnapshot();
+                            await bridge.setWallet(walletPublicKeyHash, {
+                                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,
+                            });
+                            await bridge
+                                .connect(thirdParty)
+                                .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                value: fraudChallengeDepositAmount,
+                            });
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should revert", async () => {
+                            await (0, chai_1.expect)(bridge
+                                .connect(thirdParty)
+                                .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                value: fraudChallengeDepositAmount,
+                            })).to.be.revertedWith("Fraud challenge already exists");
+                        });
+                    });
+                });
+                context("when incorrect wallet public key is used", () => {
+                    // Unrelated Bitcoin public key
+                    const incorrectWalletPublicKey = "0xffc045ade19f8a5d464299146ce069049cdcc2390a9b44d9abcd83f11d8cce4" +
+                        "01ea6800e307b87aadebdcd2f7293cc60f0526afaff1a7b1abddfd787e6c5871e";
+                    const incorrectWalletPublicKeyHash = "0xb5222794425b9b8cd8c3358e73a50dea73480927";
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(incorrectWalletPublicKeyHash, {
+                            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();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(incorrectWalletPublicKey, data.preimageSha256, data.signature, {
+                            value: fraudChallengeDepositAmount,
+                        })).to.be.revertedWith("Signature verification failure");
+                    });
+                });
+                context("when incorrect sighash is used", () => {
+                    // Random hex-string
+                    const incorrectSighash = "0x9e8e249791a5636e5e007fc15487b5a5bd6e60f73f7e236a7025cd63b904650b";
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(walletPublicKeyHash, {
+                            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();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(walletPublicKey, incorrectSighash, data.signature, {
+                            value: fraudChallengeDepositAmount,
+                        })).to.be.revertedWith("Signature verification failure");
+                    });
+                });
+                context("when incorrect recovery ID is used", () => {
+                    // Increase the value of v by 1
+                    const incorrectV = data.signature.v + 1;
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(walletPublicKeyHash, {
+                            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();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.connect(thirdParty).submitFraudChallenge(walletPublicKey, data.preimageSha256, {
+                            r: data.signature.r,
+                            s: data.signature.s,
+                            v: incorrectV,
+                        }, {
+                            value: fraudChallengeDepositAmount,
+                        })).to.be.revertedWith("Signature verification failure");
+                    });
+                });
+                context("when incorrect signature data is used", () => {
+                    // Swap r and s
+                    const incorrectS = data.signature.r;
+                    const incorrectR = data.signature.s;
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(walletPublicKeyHash, {
+                            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();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge.connect(thirdParty).submitFraudChallenge(walletPublicKey, data.preimageSha256, {
+                            r: incorrectR,
+                            s: incorrectS,
+                            v: data.signature.v,
+                        }, {
+                            value: fraudChallengeDepositAmount,
+                        })).to.be.revertedWith("Signature verification failure");
+                    });
+                });
+            });
+            context("when the amount of ETH deposited is too low", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(walletPublicKeyHash, {
+                        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();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                        value: fraudChallengeDepositAmount.sub(1),
+                    })).to.be.revertedWith("The amount of ETH deposited is too low");
+                });
+            });
+        });
+        context("when the wallet is in MovingFunds state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(walletPublicKeyHash, {
+                    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.MovingFunds,
+                    movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should succeed", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                    value: fraudChallengeDepositAmount,
+                })).to.not.be.reverted;
+            });
+        });
+        context("when the wallet is in Closing state", () => {
+            before(async () => {
+                await createSnapshot();
+                await bridge.setWallet(walletPublicKeyHash, {
+                    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.Closing,
+                    movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should succeed", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                    value: fraudChallengeDepositAmount,
+                })).to.not.be.reverted;
+            });
+        });
+        context("when the wallet is in neither Live nor MovingFunds nor Closing state", () => {
+            const testData = [
+                {
+                    testName: "when wallet state is Unknown",
+                    walletState: fixtures_1.walletState.Unknown,
+                },
+                {
+                    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(walletPublicKeyHash, {
+                            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
+                            .connect(thirdParty)
+                            .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                            value: fraudChallengeDepositAmount,
+                        })).to.be.revertedWith("Wallet must be in Live or MovingFunds or Closing state");
+                    });
+                });
+            });
+        });
+    });
+    describe("defeatFraudChallengeWithHeartbeat", () => {
+        let heartbeatWalletPublicKey;
+        let heartbeatWalletPublicKeyHash;
+        let heartbeatWalletSigningKey;
+        before(async () => {
+            await createSnapshot();
+            // For `defeatFraudChallengeWithHeartbeat` unit tests we do not use test
+            // data from `fraud.ts`. Instead, we create random wallet and use its
+            // SigningKey.
+            //
+            // This approach is better long-term. In case the format of the heartbeat
+            // message changes or in case we want to add more unit tests, we can simply
+            // call appropriate function to compute another signature. Also, we do not
+            // use any BTC-specific data for this set of unit tests.
+            const wallet = hardhat_1.ethers.Wallet.createRandom();
+            // We use `ethers.utils.SigningKey` for a `Wallet` instead of
+            // `Signer.signMessage` to do not add '\x19Ethereum Signed Message:\n'
+            // prefix to the signed message. The format of the heartbeat message is
+            // the same no matter on which host chain TBTC is deployed.
+            heartbeatWalletSigningKey = new hardhat_1.ethers.utils.SigningKey(wallet.privateKey);
+            // Public key obtained as `wallet.publicKey` is an uncompressed key,
+            // prefixed with `0x04`. To compute raw ECDSA key, we need to drop `0x04`.
+            heartbeatWalletPublicKey = `0x${wallet.publicKey.substring(4)}`;
+            const walletID = keccak256(heartbeatWalletPublicKey);
+            const walletPublicKeyX = `0x${heartbeatWalletPublicKey.substring(2, 66)}`;
+            const walletPublicKeyY = `0x${heartbeatWalletPublicKey.substring(66)}`;
+            await bridge
+                .connect(walletRegistry.wallet)
+                .__ecdsaWalletCreatedCallback(walletID, walletPublicKeyX, walletPublicKeyY);
+            heartbeatWalletPublicKeyHash = await bridge.activeWalletPubKeyHash();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when the challenge exists", () => {
+            context("when the challenge is open", () => {
+                context("when the heartbeat message has correct format", () => {
+                    const heartbeatMessage = "0xFFFFFFFFFFFFFFFF0000000000E0EED7";
+                    const heartbeatMessageSha256 = sha256(heartbeatMessage);
+                    const sighash = sha256(heartbeatMessageSha256);
+                    let tx;
+                    before(async () => {
+                        await createSnapshot();
+                        const signature = hardhat_1.ethers.utils.splitSignature(heartbeatWalletSigningKey.signDigest(sighash));
+                        await bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(heartbeatWalletPublicKey, heartbeatMessageSha256, signature, {
+                            value: fraudChallengeDepositAmount,
+                        });
+                        tx = await bridge
+                            .connect(thirdParty)
+                            .defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, heartbeatMessage);
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should mark the challenge as resolved", async () => {
+                        const challengeKey = buildChallengeKey(heartbeatWalletPublicKey, sighash);
+                        const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                        (0, chai_1.expect)(fraudChallenge.resolved).to.equal(true);
+                    });
+                    it("should send the ether deposited by the challenger to the treasury", async () => {
+                        await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                        await (0, chai_1.expect)(tx).to.changeEtherBalance(treasury, fraudChallengeDepositAmount);
+                    });
+                    it("should emit FraudChallengeDefeated event", async () => {
+                        await (0, chai_1.expect)(tx)
+                            .to.emit(bridge, "FraudChallengeDefeated")
+                            .withArgs(heartbeatWalletPublicKeyHash, sighash);
+                    });
+                });
+                context("when the heartbeat message has no correct format", () => {
+                    const notHeartbeatMessage = "0xAAFFFFFFFFFFFFFF0000000000E0EED7";
+                    const heartbeatMessageSha256 = sha256(notHeartbeatMessage);
+                    const sighash = sha256(heartbeatMessageSha256);
+                    before(async () => {
+                        await createSnapshot();
+                        const signature = hardhat_1.ethers.utils.splitSignature(heartbeatWalletSigningKey.signDigest(sighash));
+                        await bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(heartbeatWalletPublicKey, heartbeatMessageSha256, signature, {
+                            value: fraudChallengeDepositAmount,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(thirdParty)
+                            .defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, notHeartbeatMessage)).to.be.revertedWith("Not a valid heartbeat message");
+                    });
+                });
+            });
+            context("when the challenge is resolved by defeat", () => {
+                const heartbeatMessage = "0xFFFFFFFFFFFFFFFF0000000000E0EED7";
+                const heartbeatMessageSha256 = sha256(heartbeatMessage);
+                const sighash = sha256(heartbeatMessageSha256);
+                before(async () => {
+                    await createSnapshot();
+                    const signature = hardhat_1.ethers.utils.splitSignature(heartbeatWalletSigningKey.signDigest(sighash));
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(heartbeatWalletPublicKey, heartbeatMessageSha256, signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, heartbeatMessage);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, heartbeatMessage)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+            context("when the challenge is resolved by timeout", () => {
+                const heartbeatMessage = "0xFFFFFFFFFFFFFFFF0000000000E0EED7";
+                const heartbeatMessageSha256 = sha256(heartbeatMessage);
+                const sighash = sha256(heartbeatMessageSha256);
+                before(async () => {
+                    await createSnapshot();
+                    const signature = hardhat_1.ethers.utils.splitSignature(heartbeatWalletSigningKey.signDigest(sighash));
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(heartbeatWalletPublicKey, heartbeatMessageSha256, signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await increaseTime(fraudChallengeDefeatTimeout);
+                    await bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(heartbeatWalletPublicKey, [], heartbeatMessageSha256);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, heartbeatMessage)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+        });
+        context("when the challenge does not exist", () => {
+            const heartbeatMessage = "0xFFFFFFFFFFFFFFFF0000000000E0EED7";
+            const heartbeatMessageSha256 = sha256(heartbeatMessage);
+            const sighash = sha256(heartbeatMessageSha256);
+            before(async () => {
+                await createSnapshot();
+                const signature = hardhat_1.ethers.utils.splitSignature(heartbeatWalletSigningKey.signDigest(sighash));
+                await bridge
+                    .connect(thirdParty)
+                    .submitFraudChallenge(heartbeatWalletPublicKey, heartbeatMessageSha256, signature, {
+                    value: fraudChallengeDepositAmount,
+                });
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge.connect(thirdParty).defeatFraudChallengeWithHeartbeat(heartbeatWalletPublicKey, "0xFFFFFFFFFFFFFFFF0000000000E0EED8" // ...D7 -> ...D8
+                )).to.be.revertedWith("Fraud challenge does not exist");
+            });
+        });
+    });
+    describe("defeatFraudChallenge", () => {
+        context("when the challenge exists", () => {
+            context("when the challenge is open", () => {
+                context("when the sighash type is correct", () => {
+                    context("when the input is non-witness", () => {
+                        context("when the transaction has single input", () => {
+                            context("when the input is marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.nonWitnessSignSingleInputTx;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge.setSweptDeposits(data.deposits);
+                                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    tx = await bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should mark the challenge as resolved", async () => {
+                                    const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                                    const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                                    (0, chai_1.expect)(fraudChallenge.resolved).to.equal(true);
+                                });
+                                it("should send the ether deposited by the challenger to the treasury", async () => {
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(treasury, fraudChallengeDepositAmount);
+                                });
+                                it("should emit FraudChallengeDefeated event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "FraudChallengeDefeated")
+                                        .withArgs(walletPublicKeyHash, data.sighash);
+                                });
+                            });
+                            context("when the input is not marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.nonWitnessSignSingleInputTx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness)).to.be.revertedWith("Spent UTXO not found among correctly spent UTXOs");
+                                });
+                            });
+                        });
+                        context("when the transaction has multiple inputs", () => {
+                            context("when the input is marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.nonWitnessSignMultipleInputsTx;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge.setSweptDeposits(data.deposits);
+                                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    tx = await bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should mark the challenge as resolved", async () => {
+                                    const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                                    const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                                    (0, chai_1.expect)(fraudChallenge.resolved).to.equal(true);
+                                });
+                                it("should send the ether deposited by the challenger to the treasury", async () => {
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(treasury, fraudChallengeDepositAmount);
+                                });
+                                it("should emit FraudChallengeDefeated event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "FraudChallengeDefeated")
+                                        .withArgs(walletPublicKeyHash, data.sighash);
+                                });
+                            });
+                            context("when the input is not marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.nonWitnessSignMultipleInputsTx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness)).to.be.revertedWith("Spent UTXO not found among correctly spent UTXOs");
+                                });
+                            });
+                        });
+                    });
+                    context("when the input is witness", () => {
+                        context("when the transaction has single input", () => {
+                            context("when the input is marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.witnessSignSingleInputTx;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge.setSweptDeposits(data.deposits);
+                                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    tx = await bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should mark the challenge as resolved", async () => {
+                                    const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                                    const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                                    (0, chai_1.expect)(fraudChallenge.resolved).to.equal(true);
+                                });
+                                it("should send the ether deposited by the challenger to the treasury", async () => {
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(treasury, fraudChallengeDepositAmount);
+                                });
+                                it("should emit FraudChallengeDefeated event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "FraudChallengeDefeated")
+                                        .withArgs(walletPublicKeyHash, data.sighash);
+                                });
+                            });
+                            context("when the input is not marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.witnessSignSingleInputTx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness)).to.be.revertedWith("Spent UTXO not found among correctly spent UTXOs");
+                                });
+                            });
+                        });
+                        context("when the transaction has multiple inputs", () => {
+                            context("when the input is marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.witnessSignMultipleInputTx;
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge.setSweptDeposits(data.deposits);
+                                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    tx = await bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness);
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should mark the challenge as resolved", async () => {
+                                    const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                                    const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                                    (0, chai_1.expect)(fraudChallenge.resolved).to.equal(true);
+                                });
+                                it("should send the ether deposited by the challenger to the treasury", async () => {
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(treasury, fraudChallengeDepositAmount);
+                                });
+                                it("should emit FraudChallengeDefeated event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "FraudChallengeDefeated")
+                                        .withArgs(walletPublicKeyHash, data.sighash);
+                                });
+                            });
+                            context("when the input is not marked as correctly spent in the Bridge", () => {
+                                const data = fraud_1.witnessSignMultipleInputTx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        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,
+                                    });
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge
+                                        .connect(thirdParty)
+                                        .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness)).to.be.revertedWith("Spent UTXO not found among correctly spent UTXOs");
+                                });
+                            });
+                        });
+                    });
+                });
+                context("when the sighash type is incorrect", () => {
+                    // Wrong sighash was used (SIGHASH_NONE | SIGHASH_ANYONECANPAY) during
+                    // input signing
+                    const data = fraud_1.wrongSighashType;
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(walletPublicKeyHash, {
+                            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,
+                        });
+                        await bridge.setSweptDeposits(data.deposits);
+                        await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                        await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                        await bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                            value: fraudChallengeDepositAmount,
+                        });
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(thirdParty)
+                            .defeatFraudChallenge(walletPublicKey, data.preimage, data.witness)).to.be.revertedWith("Wrong sighash type");
+                    });
+                });
+            });
+            context("when the challenge is resolved by defeat", () => {
+                const data = fraud_1.nonWitnessSignSingleInputTx;
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(walletPublicKeyHash, {
+                        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,
+                    });
+                    await bridge.setSweptDeposits(data.deposits);
+                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallenge(walletPublicKey, data.preimage, false);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallenge(walletPublicKey, data.preimage, false)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+            context("when the challenge is resolved by timeout", () => {
+                const data = fraud_1.nonWitnessSignSingleInputTx;
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(walletPublicKeyHash, {
+                        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,
+                    });
+                    await bridge.setSweptDeposits(data.deposits);
+                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await increaseTime(fraudChallengeDefeatTimeout);
+                    await bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256);
+                });
+                after(async () => {
+                    walletRegistry.closeWallet.reset();
+                    walletRegistry.seize.reset();
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallenge(walletPublicKey, data.preimage, false)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+        });
+        context("when the challenge does not exist", () => {
+            const data = fraud_1.nonWitnessSignMultipleInputsTx;
+            before(async () => {
+                await createSnapshot();
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .defeatFraudChallenge(walletPublicKey, data.preimage, false)).to.be.revertedWith("Fraud challenge does not exist");
+            });
+        });
+    });
+    describe("notifyFraudChallengeDefeatTimeout", () => {
+        const data = fraud_1.nonWitnessSignSingleInputTx;
+        context("when the fraud challenge exists", () => {
+            context("when the fraud challenge is open", () => {
+                context("when the fraud challenge has timed out", () => {
+                    const walletDraft = {
+                        ecdsaWalletID: ecdsa_1.ecdsaWalletTestData.walletID,
+                        mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                        pendingRedemptionsValue: 0,
+                        createdAt: 0,
+                        movingFundsRequestedAt: 0,
+                        closingStartedAt: 0,
+                        pendingMovedFundsSweepRequestsCount: 0,
+                        state: fixtures_1.walletState.Unknown,
+                        movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                    };
+                    const walletMembersIDs = [1, 2, 3, 4, 5];
+                    context("when the wallet is in the Live or MovingFunds or Closing state", () => {
+                        const testData = [
+                            {
+                                testName: "when wallet state is Live but the wallet is not the active one",
+                                walletState: fixtures_1.walletState.Live,
+                                additionalSetup: async () => {
+                                    // The active wallet is a different wallet than the active one
+                                    await bridge.setActiveWallet("0x0b9f85c224b0e018a5865392927b3f9e16cf5e79");
+                                },
+                                additionalAssertions: async () => {
+                                    it("should decrease the live wallets count", async () => {
+                                        (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                                    });
+                                    it("should not unset the active wallet", async () => {
+                                        (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.not.equal("0x0000000000000000000000000000000000000000");
+                                    });
+                                },
+                            },
+                            {
+                                testName: "when wallet state is Live and the wallet is the active one",
+                                walletState: fixtures_1.walletState.Live,
+                                additionalSetup: async () => {
+                                    await bridge.setActiveWallet(walletPublicKeyHash);
+                                },
+                                additionalAssertions: async () => {
+                                    it("should decrease the live wallets count", async () => {
+                                        (0, chai_1.expect)(await bridge.liveWalletsCount()).to.be.equal(0);
+                                    });
+                                    it("should unset the active wallet", async () => {
+                                        (0, chai_1.expect)(await bridge.activeWalletPubKeyHash()).to.be.equal("0x0000000000000000000000000000000000000000");
+                                    });
+                                },
+                            },
+                            {
+                                testName: "when wallet state is MovingFunds",
+                                walletState: fixtures_1.walletState.MovingFunds,
+                                additionalSetup: async () => { },
+                                additionalAssertions: async () => { },
+                            },
+                            {
+                                testName: "when wallet state is Closing",
+                                walletState: fixtures_1.walletState.Closing,
+                                additionalSetup: async () => { },
+                                additionalAssertions: async () => { },
+                            },
+                        ];
+                        testData.forEach((test) => {
+                            context(test.testName, async () => {
+                                let tx;
+                                before(async () => {
+                                    await createSnapshot();
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        ...walletDraft,
+                                        state: test.walletState,
+                                    });
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    await increaseTime(fraudChallengeDefeatTimeout);
+                                    await test.additionalSetup();
+                                    tx = await bridge
+                                        .connect(thirdParty)
+                                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, walletMembersIDs, data.preimageSha256);
+                                });
+                                after(async () => {
+                                    walletRegistry.closeWallet.reset();
+                                    walletRegistry.seize.reset();
+                                    await restoreSnapshot();
+                                });
+                                it("should mark the fraud challenge as resolved", async () => {
+                                    const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                                    const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                                    (0, chai_1.expect)(fraudChallenge.resolved).to.be.true;
+                                });
+                                it("should return the deposited ether to the challenger", async () => {
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                                    await (0, chai_1.expect)(tx).to.changeEtherBalance(thirdParty, fraudChallengeDepositAmount);
+                                });
+                                it("should emit FraudChallengeDefeatTimedOut event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "FraudChallengeDefeatTimedOut")
+                                        .withArgs(walletPublicKeyHash, data.sighash);
+                                });
+                                it("should change the wallet state to Terminated", async () => {
+                                    (0, chai_1.expect)((await bridge.wallets(walletPublicKeyHash)).state).to.be.equal(fixtures_1.walletState.Terminated);
+                                });
+                                it("should emit WalletTerminated event", async () => {
+                                    await (0, chai_1.expect)(tx)
+                                        .to.emit(bridge, "WalletTerminated")
+                                        .withArgs(walletDraft.ecdsaWalletID, walletPublicKeyHash);
+                                });
+                                it("should call the ECDSA wallet registry's closeWallet function", async () => {
+                                    (0, chai_1.expect)(walletRegistry.closeWallet).to.have.been.calledOnceWith(walletDraft.ecdsaWalletID);
+                                });
+                                it("should call the ECDSA wallet registry's seize function", async () => {
+                                    (0, chai_1.expect)(walletRegistry.seize).to.have.been.calledOnceWith(fraudSlashingAmount, fraudNotifierRewardMultiplier, await thirdParty.getAddress(), ecdsa_1.ecdsaWalletTestData.walletID, walletMembersIDs);
+                                });
+                                // TODO: Check if the gas consumption of functions calling `seize`
+                                //       is not too high (use a real `staking` and `walletRegistry`).
+                                //       Perhaps add a separate deployment with the non-mocked contracts
+                                //       or test it in a system test?
+                                await test.additionalAssertions();
+                            });
+                        });
+                    });
+                    context("when the wallet is in the Terminated state", () => {
+                        let tx;
+                        before(async () => {
+                            await createSnapshot();
+                            // First, the wallet must be Live to make fraud challenge
+                            // submission possible.
+                            await bridge.setWallet(walletPublicKeyHash, {
+                                ...walletDraft,
+                                state: fixtures_1.walletState.Live,
+                            });
+                            await bridge
+                                .connect(thirdParty)
+                                .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                value: fraudChallengeDepositAmount,
+                            });
+                            await increaseTime(fraudChallengeDefeatTimeout);
+                            // Then, the state of the wallet changes to the Terminated
+                            // state.
+                            await bridge.setWallet(walletPublicKeyHash, {
+                                ...walletDraft,
+                                state: fixtures_1.walletState.Terminated,
+                            });
+                            tx = await bridge
+                                .connect(thirdParty)
+                                .notifyFraudChallengeDefeatTimeout(walletPublicKey, walletMembersIDs, data.preimageSha256);
+                        });
+                        after(async () => {
+                            await restoreSnapshot();
+                        });
+                        it("should mark the fraud challenge as resolved", async () => {
+                            const challengeKey = buildChallengeKey(walletPublicKey, data.sighash);
+                            const fraudChallenge = await bridge.fraudChallenges(challengeKey);
+                            (0, chai_1.expect)(fraudChallenge.resolved).to.be.true;
+                        });
+                        it("should return the deposited ether to the challenger", async () => {
+                            await (0, chai_1.expect)(tx).to.changeEtherBalance(bridge, fraudChallengeDepositAmount.mul(-1));
+                            await (0, chai_1.expect)(tx).to.changeEtherBalance(thirdParty, fraudChallengeDepositAmount);
+                        });
+                        it("should emit FraudChallengeDefeatTimedOut event", async () => {
+                            await (0, chai_1.expect)(tx)
+                                .to.emit(bridge, "FraudChallengeDefeatTimedOut")
+                                .withArgs(walletPublicKeyHash, data.sighash);
+                        });
+                        it("should not change the wallet state", async () => {
+                            (0, chai_1.expect)((await bridge.wallets(walletPublicKeyHash)).state).to.be.equal(fixtures_1.walletState.Terminated);
+                        });
+                        it("should not call the ECDSA wallet registry's seize function", async () => {
+                            (0, chai_1.expect)(walletRegistry.seize).not.to.have.been.called;
+                        });
+                    });
+                    context("when the wallet is neither in the Live nor MovingFunds nor Closing nor Terminated state", () => {
+                        const testData = [
+                            {
+                                testName: "when the wallet is in the Unknown state",
+                                walletState: fixtures_1.walletState.Unknown,
+                            },
+                            {
+                                testName: "when the wallet is in the Closed state",
+                                walletState: fixtures_1.walletState.Closed,
+                            },
+                        ];
+                        testData.forEach((test) => {
+                            context(test.testName, () => {
+                                before(async () => {
+                                    await createSnapshot();
+                                    // First, the wallet must be Live to make fraud challenge
+                                    // submission possible.
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        ...walletDraft,
+                                        state: fixtures_1.walletState.Live,
+                                    });
+                                    await bridge.setSweptDeposits(data.deposits);
+                                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                                    await bridge
+                                        .connect(thirdParty)
+                                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                                        value: fraudChallengeDepositAmount,
+                                    });
+                                    await increaseTime(fraudChallengeDefeatTimeout);
+                                    // Then, the state of the wallet changes to the tested
+                                    // state.
+                                    await bridge.setWallet(walletPublicKeyHash, {
+                                        ...walletDraft,
+                                        state: test.walletState,
+                                    });
+                                });
+                                after(async () => {
+                                    await restoreSnapshot();
+                                });
+                                it("should revert", async () => {
+                                    await (0, chai_1.expect)(bridge
+                                        .connect(thirdParty)
+                                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256)).to.be.revertedWith("Wallet must be in Live or MovingFunds or Closing or Terminated state");
+                                });
+                            });
+                        });
+                    });
+                });
+                context("when the fraud challenge has not timed out yet", () => {
+                    before(async () => {
+                        await createSnapshot();
+                        await bridge.setWallet(walletPublicKeyHash, {
+                            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,
+                        });
+                        await bridge.setSweptDeposits(data.deposits);
+                        await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                        await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                        await bridge
+                            .connect(thirdParty)
+                            .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                            value: fraudChallengeDepositAmount,
+                        });
+                        await increaseTime(fraudChallengeDefeatTimeout.sub(2));
+                    });
+                    after(async () => {
+                        await restoreSnapshot();
+                    });
+                    it("should revert", async () => {
+                        await (0, chai_1.expect)(bridge
+                            .connect(thirdParty)
+                            .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256)).to.be.revertedWith("Fraud challenge defeat period did not time out yet");
+                    });
+                });
+            });
+            context("when the fraud challenge is resolved by challenge defeat", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(walletPublicKeyHash, {
+                        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,
+                    });
+                    await bridge.setSweptDeposits(data.deposits);
+                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await bridge
+                        .connect(thirdParty)
+                        .defeatFraudChallenge(walletPublicKey, data.preimage, false);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+            context("when the fraud challenge is resolved by previous timeout notification", () => {
+                before(async () => {
+                    await createSnapshot();
+                    await bridge.setWallet(walletPublicKeyHash, {
+                        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,
+                    });
+                    await bridge.setSweptDeposits(data.deposits);
+                    await bridge.setSpentMainUtxos(data.spentMainUtxos);
+                    await bridge.setProcessedMovedFundsSweepRequests(data.movedFundsSweepRequests);
+                    await bridge
+                        .connect(thirdParty)
+                        .submitFraudChallenge(walletPublicKey, data.preimageSha256, data.signature, {
+                        value: fraudChallengeDepositAmount,
+                    });
+                    await increaseTime(fraudChallengeDefeatTimeout);
+                    await bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(thirdParty)
+                        .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256)).to.be.revertedWith("Fraud challenge has already been resolved");
+                });
+            });
+        });
+        context("when the fraud challenge does not exist", () => {
+            before(async () => {
+                await createSnapshot();
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .notifyFraudChallengeDefeatTimeout(walletPublicKey, [], data.preimageSha256)).to.be.revertedWith("Fraud challenge does not exist");
+            });
+        });
+    });
+    function buildChallengeKey(publicKey, sighash) {
+        return hardhat_1.ethers.utils.solidityKeccak256(["bytes", "bytes32"], [publicKey, sighash]);
+    }
+});