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

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

@@ -0,0 +1,400 @@
+"use strict";
+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 = require("chai");
+const fixtures_1 = require("../fixtures");
+const bridge_1 = __importDefault(require("../fixtures/bridge"));
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+describe("Bridge - Parameters", () => {
+    let governance;
+    let thirdParty;
+    let bridge;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ governance, thirdParty, bridge } = await hardhat_1.waffle.loadFixture(bridge_1.default));
+    });
+    describe("updateDepositParameters", () => {
+        context("when caller is the contract guvnor", () => {
+            context("when all new parameter values are correct", () => {
+                const newDepositDustThreshold = fixtures_1.constants.depositDustThreshold * 2;
+                const newDepositTreasuryFeeDivisor = fixtures_1.constants.depositTreasuryFeeDivisor * 2;
+                const newDepositTxMaxFee = fixtures_1.constants.depositTxMaxFee * 3;
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(governance)
+                        .updateDepositParameters(newDepositDustThreshold, newDepositTreasuryFeeDivisor, newDepositTxMaxFee);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should set correct values", async () => {
+                    const params = await bridge.depositParameters();
+                    (0, chai_1.expect)(params.depositDustThreshold).to.be.equal(newDepositDustThreshold);
+                    (0, chai_1.expect)(params.depositTreasuryFeeDivisor).to.be.equal(newDepositTreasuryFeeDivisor);
+                    (0, chai_1.expect)(params.depositTxMaxFee).to.be.equal(newDepositTxMaxFee);
+                });
+                it("should emit DepositParametersUpdated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "DepositParametersUpdated")
+                        .withArgs(newDepositDustThreshold, newDepositTreasuryFeeDivisor, newDepositTxMaxFee);
+                });
+            });
+            context("when new deposit dust threshold is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateDepositParameters(0, fixtures_1.constants.depositTreasuryFeeDivisor, fixtures_1.constants.depositTxMaxFee)).to.be.revertedWith("Deposit dust threshold must be greater than zero");
+                });
+            });
+            context("when new deposit treasury fee divisor is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateDepositParameters(fixtures_1.constants.depositDustThreshold, 0, fixtures_1.constants.depositTxMaxFee)).to.be.revertedWith("Deposit treasury fee divisor must be greater than zero");
+                });
+            });
+            context("when new deposit transaction max fee is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateDepositParameters(fixtures_1.constants.depositDustThreshold, fixtures_1.constants.depositTreasuryFeeDivisor, 0)).to.be.revertedWith("Deposit transaction max fee must be greater than zero");
+                });
+            });
+        });
+        context("when caller is not the contract guvnor", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .updateDepositParameters(fixtures_1.constants.depositDustThreshold, fixtures_1.constants.depositTreasuryFeeDivisor, fixtures_1.constants.depositTxMaxFee)).to.be.revertedWith("Caller is not the governance");
+            });
+        });
+    });
+    describe("updateRedemptionParameters", () => {
+        context("when caller is the contract guvnor", () => {
+            context("when all new parameter values are correct", () => {
+                const newRedemptionDustThreshold = fixtures_1.constants.redemptionDustThreshold * 2;
+                const newRedemptionTreasuryFeeDivisor = fixtures_1.constants.redemptionTreasuryFeeDivisor / 2;
+                const newRedemptionTxMaxFee = fixtures_1.constants.redemptionTxMaxFee * 3;
+                const newRedemptionTimeout = fixtures_1.constants.redemptionTimeout * 4;
+                const newRedemptionTimeoutSlashingAmount = fixtures_1.constants.redemptionTimeoutSlashingAmount.mul(2);
+                const newRedemptionTimeoutNotifierRewardMultiplier = fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier / 4;
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(governance)
+                        .updateRedemptionParameters(newRedemptionDustThreshold, newRedemptionTreasuryFeeDivisor, newRedemptionTxMaxFee, newRedemptionTimeout, newRedemptionTimeoutSlashingAmount, newRedemptionTimeoutNotifierRewardMultiplier);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should set correct values", async () => {
+                    const params = await bridge.redemptionParameters();
+                    (0, chai_1.expect)(params.redemptionDustThreshold).to.be.equal(newRedemptionDustThreshold);
+                    (0, chai_1.expect)(params.redemptionTreasuryFeeDivisor).to.be.equal(newRedemptionTreasuryFeeDivisor);
+                    (0, chai_1.expect)(params.redemptionTxMaxFee).to.be.equal(newRedemptionTxMaxFee);
+                    (0, chai_1.expect)(params.redemptionTimeout).to.be.equal(newRedemptionTimeout);
+                    (0, chai_1.expect)(params.redemptionTimeoutSlashingAmount).to.be.equal(newRedemptionTimeoutSlashingAmount);
+                    (0, chai_1.expect)(params.redemptionTimeoutNotifierRewardMultiplier).to.be.equal(newRedemptionTimeoutNotifierRewardMultiplier);
+                });
+                it("should emit RedemptionParametersUpdated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "RedemptionParametersUpdated")
+                        .withArgs(newRedemptionDustThreshold, newRedemptionTreasuryFeeDivisor, newRedemptionTxMaxFee, newRedemptionTimeout, newRedemptionTimeoutSlashingAmount, newRedemptionTimeoutNotifierRewardMultiplier);
+                });
+            });
+            context("when new redemption dust threshold is not greater than moving funds dust threshold", () => {
+                // Use the current value of `movingFundsDustThreshold` as the new value
+                // of `redemptionDustThreshold`.
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateRedemptionParameters((await bridge.movingFundsParameters()).movingFundsDustThreshold, fixtures_1.constants.redemptionTreasuryFeeDivisor, fixtures_1.constants.redemptionTxMaxFee, fixtures_1.constants.redemptionTimeout, fixtures_1.constants.redemptionTimeoutSlashingAmount, fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Redemption dust threshold must be greater than moving funds dust threshold");
+                });
+            });
+            context("when new redemption treasury fee divisor is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateRedemptionParameters(fixtures_1.constants.redemptionDustThreshold, 0, fixtures_1.constants.redemptionTxMaxFee, fixtures_1.constants.redemptionTimeout, fixtures_1.constants.redemptionTimeoutSlashingAmount, fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Redemption treasury fee divisor must be greater than zero");
+                });
+            });
+            context("when new redemption transaction max fee is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateRedemptionParameters(fixtures_1.constants.redemptionDustThreshold, fixtures_1.constants.redemptionTreasuryFeeDivisor, 0, fixtures_1.constants.redemptionTimeout, fixtures_1.constants.redemptionTimeoutSlashingAmount, fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Redemption transaction max fee must be greater than zero");
+                });
+            });
+            context("when new redemption timeout is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateRedemptionParameters(fixtures_1.constants.redemptionDustThreshold, fixtures_1.constants.redemptionTreasuryFeeDivisor, fixtures_1.constants.redemptionTxMaxFee, 0, fixtures_1.constants.redemptionTimeoutSlashingAmount, fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Redemption timeout must be greater than zero");
+                });
+            });
+            context("when new redemption timeout notifier reward multiplier is greater than 100", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateRedemptionParameters(fixtures_1.constants.redemptionDustThreshold, fixtures_1.constants.redemptionTreasuryFeeDivisor, fixtures_1.constants.redemptionTxMaxFee, fixtures_1.constants.redemptionTimeout, fixtures_1.constants.redemptionTimeoutSlashingAmount, 101)).to.be.revertedWith("Redemption timeout notifier reward multiplier must be in the range [0, 100]");
+                });
+            });
+        });
+        context("when caller is not the contract guvnor", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .updateRedemptionParameters(fixtures_1.constants.redemptionDustThreshold, fixtures_1.constants.redemptionTreasuryFeeDivisor, fixtures_1.constants.redemptionTxMaxFee, fixtures_1.constants.redemptionTimeout, fixtures_1.constants.redemptionTimeoutSlashingAmount, fixtures_1.constants.redemptionTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Caller is not the governance");
+            });
+        });
+    });
+    describe("updateMovingFundsParameters", () => {
+        context("when caller is the contract guvnor", () => {
+            context("when all new parameter values are correct", () => {
+                const newMovingFundsTxMaxTotalFee = fixtures_1.constants.movingFundsTxMaxTotalFee / 2;
+                const newMovingFundsDustThreshold = fixtures_1.constants.movingFundsDustThreshold * 2;
+                const newMovingFundsTimeoutResetDelay = fixtures_1.constants.movingFundsTimeoutResetDelay * 2;
+                const newMovingFundsTimeout = fixtures_1.constants.movingFundsTimeout * 2;
+                const newMovingFundsTimeoutSlashingAmount = fixtures_1.constants.movingFundsTimeoutSlashingAmount.mul(3);
+                const newMovingFundsTimeoutNotifierRewardMultiplier = fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier / 2;
+                const newMovedFundsSweepTxMaxTotalFee = fixtures_1.constants.movedFundsSweepTxMaxTotalFee * 2;
+                const newMovedFundsSweepTimeout = fixtures_1.constants.movedFundsSweepTimeout * 4;
+                const newMovedFundsSweepTimeoutSlashingAmount = fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount.mul(6);
+                const newMovedFundsSweepTimeoutNotifierRewardMultiplier = fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier / 4;
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(newMovingFundsTxMaxTotalFee, newMovingFundsDustThreshold, newMovingFundsTimeoutResetDelay, newMovingFundsTimeout, newMovingFundsTimeoutSlashingAmount, newMovingFundsTimeoutNotifierRewardMultiplier, newMovedFundsSweepTxMaxTotalFee, newMovedFundsSweepTimeout, newMovedFundsSweepTimeoutSlashingAmount, newMovedFundsSweepTimeoutNotifierRewardMultiplier);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should set correct values", async () => {
+                    const params = await bridge.movingFundsParameters();
+                    (0, chai_1.expect)(params.movingFundsTxMaxTotalFee).to.be.equal(newMovingFundsTxMaxTotalFee);
+                    (0, chai_1.expect)(params.movingFundsDustThreshold).to.be.equal(newMovingFundsDustThreshold);
+                    (0, chai_1.expect)(params.movingFundsTimeoutResetDelay).to.be.equal(newMovingFundsTimeoutResetDelay);
+                    (0, chai_1.expect)(params.movingFundsTimeout).to.be.equal(newMovingFundsTimeout);
+                    (0, chai_1.expect)(params.movingFundsTimeoutSlashingAmount).to.be.equal(newMovingFundsTimeoutSlashingAmount);
+                    (0, chai_1.expect)(params.movingFundsTimeoutNotifierRewardMultiplier).to.be.equal(newMovingFundsTimeoutNotifierRewardMultiplier);
+                    (0, chai_1.expect)(params.movedFundsSweepTxMaxTotalFee).to.be.equal(newMovedFundsSweepTxMaxTotalFee);
+                    (0, chai_1.expect)(params.movedFundsSweepTimeout).to.be.equal(newMovedFundsSweepTimeout);
+                    (0, chai_1.expect)(params.movedFundsSweepTimeoutSlashingAmount).to.be.equal(newMovedFundsSweepTimeoutSlashingAmount);
+                    (0, chai_1.expect)(params.movedFundsSweepTimeoutNotifierRewardMultiplier).to.be.equal(newMovedFundsSweepTimeoutNotifierRewardMultiplier);
+                });
+                it("should emit MovingFundsParametersUpdated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "MovingFundsParametersUpdated")
+                        .withArgs(newMovingFundsTxMaxTotalFee, newMovingFundsDustThreshold, newMovingFundsTimeoutResetDelay, newMovingFundsTimeout, newMovingFundsTimeoutSlashingAmount, newMovingFundsTimeoutNotifierRewardMultiplier, newMovedFundsSweepTxMaxTotalFee, newMovedFundsSweepTimeout, newMovedFundsSweepTimeoutSlashingAmount, newMovedFundsSweepTimeoutNotifierRewardMultiplier);
+                });
+            });
+            context("when new moving funds transaction max total fee is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(0, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds transaction max total fee must be greater than zero");
+                });
+            });
+            context("when new moving funds dust threshold is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, 0, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds dust threshold must be greater than zero and lower than redemption dust threshold");
+                });
+            });
+            context("when new moving funds dust threshold is not lower than redemption dust threshold", () => {
+                // Use the current value of `redemptionDustThreshold` as the new value
+                // of `movingFundsDustThreshold`.
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, (await bridge.redemptionParameters()).redemptionDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds dust threshold must be greater than zero and lower than redemption dust threshold");
+                });
+            });
+            context("when new moving funds timeout reset delay is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, 0, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds timeout reset delay must be greater than zero");
+                });
+            });
+            context("when new moving funds timeout is not greater than its reset delay", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds timeout must be greater than its reset delay");
+                });
+            });
+            context("when new moving funds timeout notifier reward multiplier is greater than 100", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, 101, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moving funds timeout notifier reward multiplier must be in the range [0, 100]");
+                });
+            });
+            context("when new moved funds sweep transaction max total fee is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, 0, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moved funds sweep transaction max total fee must be greater than zero");
+                });
+            });
+            context("when new moved funds sweep timeout is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, 0, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Moved funds sweep timeout must be greater than zero");
+                });
+            });
+            context("when new moved funds sweep timeout notifier reward multiplier is greater than 100", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, 101)).to.be.revertedWith("Moved funds sweep timeout notifier reward multiplier must be in the range [0, 100]");
+                });
+            });
+        });
+        context("when caller is not the contract guvnor", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .updateMovingFundsParameters(fixtures_1.constants.movingFundsTxMaxTotalFee, fixtures_1.constants.movingFundsDustThreshold, fixtures_1.constants.movingFundsTimeoutResetDelay, fixtures_1.constants.movingFundsTimeout, fixtures_1.constants.movingFundsTimeoutSlashingAmount, fixtures_1.constants.movingFundsTimeoutNotifierRewardMultiplier, fixtures_1.constants.movedFundsSweepTxMaxTotalFee, fixtures_1.constants.movedFundsSweepTimeout, fixtures_1.constants.movedFundsSweepTimeoutSlashingAmount, fixtures_1.constants.movedFundsSweepTimeoutNotifierRewardMultiplier)).to.be.revertedWith("Caller is not the governance");
+            });
+        });
+    });
+    describe("updateWalletParameters", () => {
+        context("when caller is the contract guvnor", () => {
+            context("when all new parameter values are correct", () => {
+                const newWalletCreationPeriod = fixtures_1.constants.walletCreationPeriod * 2;
+                const newWalletCreationMinBtcBalance = fixtures_1.constants.walletCreationMinBtcBalance.add(1000);
+                const newWalletCreationMaxBtcBalance = fixtures_1.constants.walletCreationMaxBtcBalance.add(2000);
+                const newWalletClosureMinBtcBalance = fixtures_1.constants.walletClosureMinBtcBalance.add(3000);
+                const newWalletMaxAge = fixtures_1.constants.walletMaxAge * 2;
+                const newWalletMaxBtcTransfer = fixtures_1.constants.walletMaxBtcTransfer.add(1000);
+                const newWalletClosingPeriod = fixtures_1.constants.walletClosingPeriod * 2;
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(governance)
+                        .updateWalletParameters(newWalletCreationPeriod, newWalletCreationMinBtcBalance, newWalletCreationMaxBtcBalance, newWalletClosureMinBtcBalance, newWalletMaxAge, newWalletMaxBtcTransfer, newWalletClosingPeriod);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should set correct values", async () => {
+                    const params = await bridge.walletParameters();
+                    (0, chai_1.expect)(params.walletCreationPeriod).to.be.equal(newWalletCreationPeriod);
+                    (0, chai_1.expect)(params.walletCreationMinBtcBalance).to.be.equal(newWalletCreationMinBtcBalance);
+                    (0, chai_1.expect)(params.walletCreationMaxBtcBalance).to.be.equal(newWalletCreationMaxBtcBalance);
+                    (0, chai_1.expect)(params.walletClosureMinBtcBalance).to.be.equal(newWalletClosureMinBtcBalance);
+                    (0, chai_1.expect)(params.walletMaxAge).to.be.equal(newWalletMaxAge);
+                    (0, chai_1.expect)(params.walletMaxBtcTransfer).to.be.equal(newWalletMaxBtcTransfer);
+                    (0, chai_1.expect)(params.walletClosingPeriod).to.be.equal(newWalletClosingPeriod);
+                });
+                it("should emit WalletParametersUpdated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "WalletParametersUpdated")
+                        .withArgs(newWalletCreationPeriod, newWalletCreationMinBtcBalance, newWalletCreationMaxBtcBalance, newWalletClosureMinBtcBalance, newWalletMaxAge, newWalletMaxBtcTransfer, newWalletClosingPeriod);
+                });
+            });
+            context("when new creation maximum BTC balance is not greater than the creation minimum BTC balance", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateWalletParameters(fixtures_1.constants.walletCreationPeriod, fixtures_1.constants.walletCreationMinBtcBalance, fixtures_1.constants.walletCreationMinBtcBalance, fixtures_1.constants.walletClosureMinBtcBalance, fixtures_1.constants.walletMaxAge, fixtures_1.constants.walletMaxBtcTransfer, fixtures_1.constants.walletClosingPeriod)).to.be.revertedWith("Wallet creation maximum BTC balance must be greater than the creation minimum BTC balance");
+                });
+            });
+            context("when new closure minimum BTC balance is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateWalletParameters(fixtures_1.constants.walletCreationPeriod, fixtures_1.constants.walletClosureMinBtcBalance, fixtures_1.constants.walletCreationMaxBtcBalance, 0, fixtures_1.constants.walletMaxAge, fixtures_1.constants.walletMaxBtcTransfer, fixtures_1.constants.walletClosingPeriod)).to.be.revertedWith("Wallet closure minimum BTC balance must be greater than zero");
+                });
+            });
+            context("when new maximum BTC transfer is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateWalletParameters(fixtures_1.constants.walletCreationPeriod, fixtures_1.constants.walletCreationMinBtcBalance, fixtures_1.constants.walletCreationMaxBtcBalance, fixtures_1.constants.walletClosureMinBtcBalance, fixtures_1.constants.walletMaxAge, 0, fixtures_1.constants.walletClosingPeriod)).to.be.revertedWith("Wallet maximum BTC transfer must be greater than zero");
+                });
+            });
+            context("when new closing period is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateWalletParameters(fixtures_1.constants.walletCreationPeriod, fixtures_1.constants.walletCreationMinBtcBalance, fixtures_1.constants.walletCreationMaxBtcBalance, fixtures_1.constants.walletClosureMinBtcBalance, fixtures_1.constants.walletMaxAge, fixtures_1.constants.walletMaxBtcTransfer, 0)).to.be.revertedWith("Wallet closing period must be greater than zero");
+                });
+            });
+        });
+        context("when caller is not the contract guvnor", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .updateWalletParameters(fixtures_1.constants.walletCreationPeriod, fixtures_1.constants.walletCreationMinBtcBalance, fixtures_1.constants.walletCreationMaxBtcBalance, fixtures_1.constants.walletClosureMinBtcBalance, fixtures_1.constants.walletMaxAge, fixtures_1.constants.walletMaxBtcTransfer, fixtures_1.constants.walletClosingPeriod)).to.be.revertedWith("Caller is not the governance");
+            });
+        });
+    });
+    describe("updateFraudParameters", () => {
+        context("when caller is the contract guvnor", () => {
+            context("when all new parameter values are correct", () => {
+                const newFraudChallengeDepositAmount = fixtures_1.constants.fraudChallengeDepositAmount.mul(4);
+                const newFraudChallengeDefeatTimeout = fixtures_1.constants.fraudChallengeDefeatTimeout * 3;
+                const newFraudSlashingAmount = fixtures_1.constants.fraudSlashingAmount.mul(2);
+                const newFraudNotifierRewardMultiplier = fixtures_1.constants.fraudNotifierRewardMultiplier / 4;
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bridge
+                        .connect(governance)
+                        .updateFraudParameters(newFraudChallengeDepositAmount, newFraudChallengeDefeatTimeout, newFraudSlashingAmount, newFraudNotifierRewardMultiplier);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should set correct values", async () => {
+                    const params = await bridge.fraudParameters();
+                    (0, chai_1.expect)(params.fraudChallengeDepositAmount).to.be.equal(newFraudChallengeDepositAmount);
+                    (0, chai_1.expect)(params.fraudChallengeDefeatTimeout).to.be.equal(newFraudChallengeDefeatTimeout);
+                    (0, chai_1.expect)(params.fraudSlashingAmount).to.be.equal(newFraudSlashingAmount);
+                    (0, chai_1.expect)(params.fraudNotifierRewardMultiplier).to.be.equal(newFraudNotifierRewardMultiplier);
+                });
+                it("should emit FraudParametersUpdated event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bridge, "FraudParametersUpdated")
+                        .withArgs(newFraudChallengeDepositAmount, newFraudChallengeDefeatTimeout, newFraudSlashingAmount, newFraudNotifierRewardMultiplier);
+                });
+            });
+            context("when new fraud challenge defeat timeout is zero", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateFraudParameters(fixtures_1.constants.fraudChallengeDepositAmount, 0, fixtures_1.constants.fraudSlashingAmount, fixtures_1.constants.fraudNotifierRewardMultiplier)).to.be.revertedWith("Fraud challenge defeat timeout must be greater than zero");
+                });
+            });
+            context("when new fraud notifier reward multiplier is greater than 100", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bridge
+                        .connect(governance)
+                        .updateFraudParameters(fixtures_1.constants.fraudChallengeDepositAmount, fixtures_1.constants.fraudChallengeDefeatTimeout, fixtures_1.constants.fraudSlashingAmount, 101)).to.be.revertedWith("Fraud notifier reward multiplier must be in the range [0, 100]");
+                });
+            });
+        });
+        context("when caller is not the contract guvnor", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bridge
+                    .connect(thirdParty)
+                    .updateFraudParameters(fixtures_1.constants.fraudChallengeDepositAmount, fixtures_1.constants.fraudChallengeDefeatTimeout, fixtures_1.constants.fraudSlashingAmount, fixtures_1.constants.fraudNotifierRewardMultiplier)).to.be.revertedWith("Caller is not the governance");
+            });
+        });
+    });
+});