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

package/export/test/bank/Bank.test.js

@@ -0,0 +1,1012 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const chai_1 = __importStar(require("chai"));
+const smock_1 = require("@defi-wonderland/smock");
+chai_1.default.use(smock_1.smock.matchers);
+const { to1e18 } = hardhat_1.helpers.number;
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const ZERO_ADDRESS = hardhat_1.ethers.constants.AddressZero;
+const MAX_UINT256 = hardhat_1.ethers.constants.MaxUint256;
+const fixture = async () => {
+    const [deployer, governance, bridge, thirdParty] = await hardhat_1.ethers.getSigners();
+    const Bank = await hardhat_1.ethers.getContractFactory("Bank");
+    const bank = await Bank.deploy();
+    await bank.deployed();
+    await bank.connect(deployer).updateBridge(bridge.address);
+    await bank.connect(deployer).transferOwnership(governance.address);
+    return {
+        deployer,
+        governance,
+        bridge,
+        thirdParty,
+        bank,
+    };
+};
+describe("Bank", () => {
+    // default Hardhat's networks blockchain, see https://hardhat.org/config/
+    const hardhatNetworkId = 31337;
+    let deployer;
+    let governance;
+    let bridge;
+    let thirdParty;
+    let bank;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ deployer, governance, bridge, thirdParty, bank } =
+            await hardhat_1.waffle.loadFixture(fixture));
+    });
+    describe("PERMIT_TYPEHASH", () => {
+        it("should be keccak256 of EIP2612 Permit message", async () => {
+            const expected = hardhat_1.ethers.utils.keccak256(hardhat_1.ethers.utils.toUtf8Bytes("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"));
+            (0, chai_1.expect)(await bank.PERMIT_TYPEHASH()).to.equal(expected);
+            // double-checking...
+            (0, chai_1.expect)(await bank.PERMIT_TYPEHASH()).to.equal("0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9");
+        });
+    });
+    describe("updateBridge", () => {
+        before(async () => {
+            await createSnapshot();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when called by a third party", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(thirdParty).updateBridge(thirdParty.address)).to.be.revertedWith("Ownable: caller is not the owner");
+            });
+        });
+        context("when called with 0-address bridge", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(governance).updateBridge(ZERO_ADDRESS)).to.be.revertedWith("Bridge address must not be 0x0");
+            });
+        });
+        context("when called by the governance", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(governance).updateBridge(thirdParty.address);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should update the bridge", async () => {
+                (0, chai_1.expect)(await bank.bridge()).to.equal(thirdParty.address);
+            });
+            it("should emit the BridgeUpdated event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BridgeUpdated")
+                    .withArgs(thirdParty.address);
+            });
+        });
+    });
+    describe("transferBalance", () => {
+        const initialBalance = to1e18(500);
+        let spender;
+        let recipient;
+        before(async () => {
+            await createSnapshot();
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            spender = await hardhat_1.ethers.getSigner(accounts[0]);
+            // eslint-disable-next-line prefer-destructuring
+            recipient = accounts[1];
+            await bank
+                .connect(bridge)
+                .increaseBalance(spender.address, initialBalance);
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when the recipient is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(spender).transferBalance(ZERO_ADDRESS, initialBalance)).to.be.revertedWith("Can not transfer to the zero address");
+            });
+        });
+        context("when the recipient is the bank address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(spender).transferBalance(bank.address, initialBalance)).to.be.revertedWith("Can not transfer to the Bank address");
+            });
+        });
+        context("when the spender has not enough balance", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(spender)
+                    .transferBalance(recipient, initialBalance.add(1))).to.be.revertedWith("Transfer amount exceeds balance");
+            });
+        });
+        context("when the spender transfers part of their balance", () => {
+            const amount = to1e18(21);
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(spender).transferBalance(recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(spender.address)).to.equal(initialBalance.sub(amount));
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+            });
+            it("should emit the BalanceTransferred event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(spender.address, recipient, amount);
+            });
+        });
+        context("when the spender transfers part of their balance in two transactions", () => {
+            const amount1 = to1e18(21);
+            const amount2 = to1e18(12);
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(spender).transferBalance(recipient, amount1);
+                await bank.connect(spender).transferBalance(recipient, amount2);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(spender.address)).to.equal(initialBalance.sub(amount1).sub(amount2));
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount1.add(amount2));
+            });
+        });
+        context("when the spender transfers their entire balance", () => {
+            const amount = initialBalance;
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(spender).transferBalance(recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the entire balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(spender.address)).to.equal(0);
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+            });
+            it("should emit the BalanceTransferred event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(spender.address, recipient, amount);
+            });
+        });
+        context("when the spender transfers 0 balance", () => {
+            const amount = 0;
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(spender).transferBalance(recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer no balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(spender.address)).to.equal(initialBalance);
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(0);
+            });
+            it("should emit the BalanceTransferred event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(spender.address, recipient, 0);
+            });
+        });
+    });
+    describe("approveBalanceAndCall", () => {
+        const amount = to1e18(11);
+        let owner;
+        let mockVault;
+        before(async () => {
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            owner = await hardhat_1.ethers.getSigner(accounts[0]);
+            mockVault = await smock_1.smock.fake("IVault");
+        });
+        context("when the spender is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).approveBalanceAndCall(ZERO_ADDRESS, amount, [])).to.be.revertedWith("Can not approve to the zero address");
+            });
+        });
+        context("when the spender callback reverted", () => {
+            before(async () => {
+                await mockVault.receiveBalanceApproval.reverts();
+            });
+            after(async () => {
+                mockVault.receiveBalanceApproval.reset();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(owner)
+                    .approveBalanceAndCall(mockVault.address, amount, [])).to.be.reverted;
+            });
+        });
+        context("when the spender had no approved balance before", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank
+                    .connect(owner)
+                    .approveBalanceAndCall(mockVault.address, amount, "0x11");
+            });
+            after(async () => {
+                await restoreSnapshot();
+                mockVault.receiveBalanceApproval.reset();
+            });
+            it("should approve the requested amount", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, mockVault.address)).to.equal(amount);
+            });
+            it("should emit the BalanceApproved event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceApproved")
+                    .withArgs(owner.address, mockVault.address, amount);
+            });
+            it("should call receiveBalanceApproval", async () => {
+                (0, chai_1.expect)(mockVault.receiveBalanceApproval).to.have.been.calledOnceWith(owner.address, amount, "0x11");
+            });
+        });
+        context("when the spender had an approved balance before", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank
+                    .connect(owner)
+                    .approveBalance(mockVault.address, to1e18(1337));
+                await bank
+                    .connect(owner)
+                    .approveBalanceAndCall(mockVault.address, amount, "0x02");
+            });
+            after(async () => {
+                await restoreSnapshot();
+                mockVault.receiveBalanceApproval.reset();
+            });
+            it("should replace the previous allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, mockVault.address)).to.equal(amount);
+            });
+            it("should call receiveBalanceApproval", async () => {
+                (0, chai_1.expect)(mockVault.receiveBalanceApproval).to.have.been.calledOnceWith(owner.address, amount, "0x02");
+            });
+        });
+    });
+    describe("approveBalance", () => {
+        const amount = to1e18(10);
+        let owner;
+        let spender;
+        before(async () => {
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            owner = await hardhat_1.ethers.getSigner(accounts[0]);
+            // eslint-disable-next-line prefer-destructuring
+            spender = accounts[1];
+        });
+        context("when the spender is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).approveBalance(ZERO_ADDRESS, amount)).to.be.revertedWith("Can not approve to the zero address");
+            });
+        });
+        context("when the spender had no approved balance before", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(owner).approveBalance(spender, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should approve the requested amount", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(amount);
+            });
+            it("should emit the BalanceApproved event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceApproved")
+                    .withArgs(owner.address, spender, amount);
+            });
+        });
+        context("when the spender had an approved balance before", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender, to1e18(1337));
+                await bank.connect(owner).approveBalance(spender, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should replace the previous allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(amount);
+            });
+        });
+    });
+    describe("increaseBalanceAllowance", () => {
+        const amount = to1e18(12);
+        let owner;
+        let spender;
+        before(async () => {
+            await createSnapshot();
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            owner = await hardhat_1.ethers.getSigner(accounts[0]);
+            // eslint-disable-next-line prefer-destructuring
+            spender = accounts[1];
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when the spender is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).increaseBalanceAllowance(ZERO_ADDRESS, amount)).to.be.revertedWith("Can not approve");
+            });
+        });
+        context("when the spender had no approved balance before", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank.connect(owner).increaseBalanceAllowance(spender, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should approve the requested amount", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(amount);
+            });
+            it("should emit the BalanceApproved event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceApproved")
+                    .withArgs(owner.address, spender, amount);
+            });
+        });
+        context("when the spender had an approved balance before", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender, to1e18(1337));
+                await bank.connect(owner).increaseBalanceAllowance(spender, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should increase the previous allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(to1e18(1337).add(amount));
+            });
+        });
+        context("when the spender has a maximum allowance", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender, MAX_UINT256);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).increaseBalanceAllowance(spender, to1e18(1))).to.be.reverted;
+            });
+        });
+    });
+    describe("decreaseBalanceAllowance", () => {
+        const approvedAmount = to1e18(99);
+        let owner;
+        let spender;
+        before(async () => {
+            await createSnapshot();
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            owner = await hardhat_1.ethers.getSigner(accounts[0]);
+            // eslint-disable-next-line prefer-destructuring
+            spender = accounts[1];
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when the spender is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).decreaseBalanceAllowance(ZERO_ADDRESS, to1e18(1))).to.be.revertedWith("Can not decrease balance allowance below zero");
+            });
+        });
+        context("when the spender had no approved balance before", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(owner).decreaseBalanceAllowance(spender, to1e18(1))).to.be.revertedWith("Can not decrease balance allowance below zero");
+            });
+        });
+        context("when the spender had an approved balance before", () => {
+            const decreaseBy = to1e18(3);
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender, approvedAmount);
+                await bank.connect(owner).decreaseBalanceAllowance(spender, decreaseBy);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should decrease the previous allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(approvedAmount.sub(decreaseBy));
+            });
+        });
+    });
+    describe("transferBalanceFrom", () => {
+        const initialBalance = to1e18(500);
+        const approvedBalance = to1e18(45);
+        let owner;
+        let spender;
+        let recipient;
+        before(async () => {
+            await createSnapshot();
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            owner = await hardhat_1.ethers.getSigner(accounts[0]);
+            spender = await hardhat_1.ethers.getSigner(accounts[1]);
+            // eslint-disable-next-line prefer-destructuring
+            recipient = accounts[2];
+            await bank.connect(bridge).increaseBalance(owner.address, initialBalance);
+            await bank.connect(owner).approveBalance(spender.address, approvedBalance);
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when the recipient is the zero address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, ZERO_ADDRESS, approvedBalance)).to.be.revertedWith("Can not transfer to the zero address");
+            });
+        });
+        context("when the recipient is the bank address", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, bank.address, approvedBalance)).to.be.revertedWith("Can not transfer to the Bank address");
+            });
+        });
+        context("when the spender has not enough balance approved", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, approvedBalance.add(1))).to.be.revertedWith("Transfer amount exceeds allowance");
+            });
+        });
+        context("when the owner has not enough balance", () => {
+            const amount = initialBalance.add(1);
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender.address, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount)).to.be.revertedWith("Transfer amount exceeds balance");
+            });
+        });
+        context("when the spender transfers part of the approved balance", () => {
+            const amount = to1e18(2);
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(owner.address)).to.equal(initialBalance.sub(amount));
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+            });
+            it("should emit the BalanceTransferred event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(owner.address, recipient, amount);
+            });
+            it("should reduce the spender allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender.address)).to.equal(approvedBalance.sub(amount));
+            });
+        });
+        context("when the spender transfers part of the approved balance in two transactions", () => {
+            const amount1 = to1e18(1);
+            const amount2 = to1e18(3);
+            let tx1;
+            let tx2;
+            before(async () => {
+                await createSnapshot();
+                tx1 = await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount1);
+                tx2 = await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount2);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(owner.address)).to.equal(initialBalance.sub(amount1).sub(amount2));
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount1.add(amount2));
+            });
+            it("should emit BalanceTransferred events", async () => {
+                await (0, chai_1.expect)(tx1)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(owner.address, recipient, amount1);
+                await (0, chai_1.expect)(tx2)
+                    .to.emit(bank, "BalanceTransferred")
+                    .withArgs(owner.address, recipient, amount2);
+            });
+            it("should reduce the spender allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender.address)).to.equal(approvedBalance.sub(amount1).sub(amount2));
+            });
+        });
+        context("when the spender transfers the entire approved balance", async () => {
+            const amount = approvedBalance;
+            before(async () => {
+                await createSnapshot();
+                await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(owner.address)).to.equal(initialBalance.sub(amount));
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+            });
+            it("should reduce the spender allowance to zero", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender.address)).to.equal(0);
+            });
+        });
+        context("when the spender transfers the entire balance", async () => {
+            const amount = initialBalance;
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender.address, amount);
+                await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should transfer the requested amount", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(owner.address)).to.equal(0);
+                (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+            });
+            it("should reduce the spender allowance to zero", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender.address)).to.equal(0);
+            });
+        });
+        context("when given the maximum allowance", () => {
+            const allowance = MAX_UINT256;
+            const amount = to1e18(21);
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(owner).approveBalance(spender.address, allowance);
+                await bank
+                    .connect(spender)
+                    .transferBalanceFrom(owner.address, recipient, amount);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should not reduce the spender allowance", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender.address)).to.equal(allowance);
+            });
+        });
+    });
+    describe("permit", () => {
+        const initialBalance = to1e18(1231);
+        const permittedBalance = to1e18(45);
+        let owner;
+        let spender;
+        let yesterday;
+        let tomorrow;
+        before(async () => {
+            await createSnapshot();
+            owner = hardhat_1.ethers.Wallet.createRandom();
+            await bank.connect(bridge).increaseBalance(owner.address, initialBalance);
+            const accounts = await (0, hardhat_1.getUnnamedAccounts)();
+            // eslint-disable-next-line prefer-destructuring
+            spender = accounts[1];
+            const lastBlockTimestamp = await hardhat_1.helpers.time.lastBlockTime();
+            yesterday = lastBlockTimestamp - 86400; // -1 day
+            tomorrow = lastBlockTimestamp + 86400; // +1 day
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        const getApproval = async (amount, spenderAddress, deadline) => {
+            // 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 '\x19` protection (see EIP191 for
+            // more details on '\x19' rationale and format) is already included in
+            // EIP2612 permit signed message and '\x19Ethereum Signed Message:\n'
+            // should not be used there.
+            const signingKey = new hardhat_1.ethers.utils.SigningKey(owner.privateKey);
+            const domainSeparator = await bank.DOMAIN_SEPARATOR();
+            const permitTypehash = await bank.PERMIT_TYPEHASH();
+            const nonce = await bank.nonce(owner.address);
+            const approvalDigest = hardhat_1.ethers.utils.keccak256(hardhat_1.ethers.utils.solidityPack(["bytes1", "bytes1", "bytes32", "bytes32"], [
+                "0x19",
+                "0x01",
+                domainSeparator,
+                hardhat_1.ethers.utils.keccak256(hardhat_1.ethers.utils.defaultAbiCoder.encode([
+                    "bytes32",
+                    "address",
+                    "address",
+                    "uint256",
+                    "uint256",
+                    "uint256",
+                ], [
+                    permitTypehash,
+                    owner.address,
+                    spenderAddress,
+                    amount,
+                    nonce,
+                    deadline,
+                ])),
+            ]));
+            return hardhat_1.ethers.utils.splitSignature(signingKey.signDigest(approvalDigest));
+        };
+        context("when permission expired", () => {
+            it("should revert", async () => {
+                const deadline = yesterday;
+                const signature = await getApproval(permittedBalance, spender, deadline);
+                await (0, chai_1.expect)(bank
+                    .connect(thirdParty)
+                    .permit(owner.address, spender, permittedBalance, deadline, signature.v, signature.r, signature.s)).to.be.revertedWith("Permission expired");
+            });
+        });
+        context("when permission has an invalid signature", () => {
+            context("when owner does not match the permitting one", () => {
+                it("should revert", async () => {
+                    const deadline = tomorrow;
+                    const signature = await getApproval(permittedBalance, spender, deadline);
+                    await (0, chai_1.expect)(bank.connect(thirdParty).permit(thirdParty.address, // does not match the signature
+                    spender, permittedBalance, deadline, signature.v, signature.r, signature.s)).to.be.revertedWith("Invalid signature");
+                });
+            });
+            context("when spender does not match the signature", () => {
+                it("should revert", async () => {
+                    const deadline = tomorrow;
+                    const signature = await getApproval(permittedBalance, spender, deadline);
+                    await (0, chai_1.expect)(bank.connect(thirdParty).permit(owner.address, thirdParty.address, // does not match the signature
+                    permittedBalance, deadline, signature.v, signature.r, signature.s)).to.be.revertedWith("Invalid signature");
+                });
+            });
+            context("when permitted balance does not match the signature", () => {
+                it("should revert", async () => {
+                    const deadline = tomorrow;
+                    const signature = await getApproval(permittedBalance, spender, deadline);
+                    await (0, chai_1.expect)(bank.connect(thirdParty).permit(owner.address, spender, permittedBalance.add(1), // does not match the signature
+                    deadline, signature.v, signature.r, signature.s)).to.be.revertedWith("Invalid signature");
+                });
+            });
+            context("when permitted deadline does not match the signature", () => {
+                it("should revert", async () => {
+                    const deadline = tomorrow;
+                    const signature = await getApproval(permittedBalance, spender, deadline);
+                    await (0, chai_1.expect)(bank.connect(thirdParty).permit(owner.address, spender, permittedBalance, deadline + 1, // does not match the signature
+                    signature.v, signature.r, signature.s)).to.be.revertedWith("Invalid signature");
+                });
+            });
+        });
+        context("when the spender is the zero address", () => {
+            it("should revert", async () => {
+                const deadline = tomorrow;
+                const signature = await getApproval(permittedBalance, ZERO_ADDRESS, deadline);
+                await (0, chai_1.expect)(bank
+                    .connect(thirdParty)
+                    .permit(owner.address, ZERO_ADDRESS, permittedBalance, deadline, signature.v, signature.r, signature.s)).to.be.revertedWith("Can not approve to the zero address");
+            });
+        });
+        context("when the spender had no permitted balance before", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                const deadline = tomorrow;
+                const signature = await getApproval(permittedBalance, spender, deadline);
+                tx = await bank
+                    .connect(thirdParty)
+                    .permit(owner.address, spender, permittedBalance, deadline, signature.v, signature.r, signature.s);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should approve the requested amount", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(permittedBalance);
+            });
+            it("should emit the BalanceApproved event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceApproved")
+                    .withArgs(owner.address, spender, permittedBalance);
+            });
+            it("should increment the nonce for the permitting owner", async () => {
+                (0, chai_1.expect)(await bank.nonce(owner.address)).to.equal(1);
+                (0, chai_1.expect)(await bank.nonce(spender)).to.equal(0);
+            });
+        });
+        context("when the spender had a permitted balance before", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                const deadline = tomorrow;
+                let signature = await getApproval(to1e18(1337), spender, deadline);
+                await bank
+                    .connect(thirdParty)
+                    .permit(owner.address, spender, to1e18(1337), deadline, signature.v, signature.r, signature.s);
+                signature = await getApproval(permittedBalance, spender, deadline);
+                tx = await bank
+                    .connect(thirdParty)
+                    .permit(owner.address, spender, permittedBalance, deadline, signature.v, signature.r, signature.s);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should replace the previous approval", async () => {
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(permittedBalance);
+            });
+            it("should emit the BalanceApproved event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceApproved")
+                    .withArgs(owner.address, spender, permittedBalance);
+            });
+            it("should increment the nonce for the permitting owner", async () => {
+                (0, chai_1.expect)(await bank.nonce(owner.address)).to.equal(2);
+                (0, chai_1.expect)(await bank.nonce(spender)).to.equal(0);
+            });
+        });
+        context("when given never expiring permit", () => {
+            const deadline = MAX_UINT256;
+            let signature;
+            before(async () => {
+                await createSnapshot();
+                signature = await getApproval(permittedBalance, spender, deadline);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should be accepted at any moment", async () => {
+                await hardhat_1.helpers.time.increaseTime(63113904); // +2 years
+                await bank
+                    .connect(thirdParty)
+                    .permit(owner.address, spender, permittedBalance, deadline, signature.v, signature.r, signature.s);
+                (0, chai_1.expect)(await bank.allowance(owner.address, spender)).to.equal(permittedBalance);
+            });
+        });
+    });
+    describe("increaseBalance", () => {
+        const amount = to1e18(10);
+        let recipient;
+        before(async () => {
+            await createSnapshot();
+            recipient = thirdParty.address;
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when called by a third party", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(thirdParty).increaseBalance(recipient, amount)).to.be.revertedWith("Caller is not the bridge");
+            });
+        });
+        context("when called by the bridge", () => {
+            context("when increasing balance for the Bank", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank.connect(bridge).increaseBalance(bank.address, amount)).to.be.revertedWith("Can not increase balance for Bank");
+                });
+            });
+            context("when called for a valid recipient", () => {
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bank.connect(bridge).increaseBalance(recipient, amount);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should increase recipient's balance", async () => {
+                    (0, chai_1.expect)(await bank.balanceOf(recipient)).to.equal(amount);
+                });
+                it("should emit the BalanceIncreased event", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bank, "BalanceIncreased")
+                        .withArgs(recipient, amount);
+                });
+            });
+        });
+    });
+    describe("increaseBalances", () => {
+        const amount1 = to1e18(12);
+        const amount2 = to1e18(15);
+        const amount3 = to1e18(17);
+        let recipient1;
+        let recipient2;
+        let recipient3;
+        before(async () => {
+            await createSnapshot();
+            [recipient1, recipient2, recipient3] = await (0, hardhat_1.getUnnamedAccounts)();
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when called by a third party", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(thirdParty)
+                    .increaseBalances([recipient1, recipient2, recipient3], [amount1, amount2, amount3])).to.be.revertedWith("Caller is not the bridge");
+            });
+        });
+        context("when called by the bridge", () => {
+            context("when increasing balance for the bank", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank
+                        .connect(bridge)
+                        .increaseBalances([recipient1, bank.address, recipient3], [amount1, amount2, amount3])).to.be.revertedWith("Can not increase balance for Bank");
+                });
+            });
+            context("when there is more recipients than amounts", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank
+                        .connect(bridge)
+                        .increaseBalances([recipient1, recipient2], [amount1])).to.be.revertedWith("Arrays must have the same length");
+                });
+            });
+            context("when there is more amounts than recipients", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank
+                        .connect(bridge)
+                        .increaseBalances([recipient1, recipient2], [amount1, amount2, amount3])).to.be.revertedWith("Arrays must have the same length");
+                });
+            });
+            context("when called for a valid recipient", () => {
+                let tx;
+                before(async () => {
+                    await createSnapshot();
+                    tx = await bank
+                        .connect(bridge)
+                        .increaseBalances([recipient1, recipient2, recipient3], [amount1, amount2, amount3]);
+                });
+                after(async () => {
+                    await restoreSnapshot();
+                });
+                it("should increase recipients' balances", async () => {
+                    (0, chai_1.expect)(await bank.balanceOf(recipient1)).to.equal(amount1);
+                    (0, chai_1.expect)(await bank.balanceOf(recipient2)).to.equal(amount2);
+                    (0, chai_1.expect)(await bank.balanceOf(recipient3)).to.equal(amount3);
+                });
+                it("should emit BalanceIncreased events", async () => {
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bank, "BalanceIncreased")
+                        .withArgs(recipient1, amount1);
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bank, "BalanceIncreased")
+                        .withArgs(recipient2, amount2);
+                    await (0, chai_1.expect)(tx)
+                        .to.emit(bank, "BalanceIncreased")
+                        .withArgs(recipient3, amount3);
+                });
+            });
+        });
+    });
+    describe("increaseBalanceAndCall", () => {
+        const depositor1 = "0x30c371E0651B2Ff6062158ca1D95b07C7531c719";
+        const depositor2 = "0xb3464806d680722dBc678996F1670D19A42eA3e9";
+        const depositedAmount1 = to1e18(19);
+        const depositedAmount2 = to1e18(11);
+        const totalDepositedAmount = to1e18(30); // 19 + 11
+        let vault;
+        let tbtc;
+        before(async () => {
+            await createSnapshot();
+            const TBTC = await hardhat_1.ethers.getContractFactory("TBTC");
+            tbtc = await TBTC.deploy();
+            await tbtc.deployed();
+            const Vault = await hardhat_1.ethers.getContractFactory("TBTCVault");
+            vault = await Vault.deploy(bank.address, tbtc.address);
+            await vault.deployed();
+            await tbtc.connect(deployer).transferOwnership(vault.address);
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        context("when called by a third party", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank
+                    .connect(thirdParty)
+                    .increaseBalanceAndCall(vault.address, [depositor1, depositor2], [depositedAmount1, depositedAmount2])).to.be.revertedWith("Caller is not the bridge");
+            });
+        });
+        context("when called by the bridge", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank
+                    .connect(bridge)
+                    .increaseBalanceAndCall(vault.address, [depositor1, depositor2], [depositedAmount1, depositedAmount2]);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            context("when depositors array has greater length than deposited amounts array", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank
+                        .connect(bridge)
+                        .increaseBalanceAndCall(vault.address, [depositor1, depositor2], [depositedAmount1])).to.be.revertedWith("Arrays must have the same length");
+                });
+            });
+            context("when deposited amounts array has greater length than depositors array", () => {
+                it("should revert", async () => {
+                    await (0, chai_1.expect)(bank
+                        .connect(bridge)
+                        .increaseBalanceAndCall(vault.address, [depositor1], [depositedAmount1, depositedAmount2])).to.be.revertedWith("Arrays must have the same length");
+                });
+            });
+            it("should increase vault's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.equal(totalDepositedAmount);
+            });
+            it("should emit BalanceIncreased event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceIncreased")
+                    .withArgs(vault.address, totalDepositedAmount);
+            });
+            it("should call the vault", async () => {
+                (0, chai_1.expect)(await tbtc.balanceOf(depositor1)).to.equal(depositedAmount1);
+                (0, chai_1.expect)(await tbtc.balanceOf(depositor2)).to.equal(depositedAmount2);
+                (0, chai_1.expect)(await tbtc.totalSupply()).to.equal(totalDepositedAmount);
+            });
+        });
+    });
+    describe("decreaseBalance", () => {
+        const initialBalance = to1e18(21);
+        const amount = to1e18(10);
+        let tx;
+        before(async () => {
+            await createSnapshot();
+            // first increase so that there is something to decrease from
+            await bank
+                .connect(bridge)
+                .increaseBalance(thirdParty.address, initialBalance);
+            tx = await bank.connect(thirdParty).decreaseBalance(amount);
+        });
+        after(async () => {
+            await restoreSnapshot();
+        });
+        it("should decrease caller's balance", async () => {
+            (0, chai_1.expect)(await bank.balanceOf(thirdParty.address)).to.equal(initialBalance.sub(amount));
+        });
+        it("should emit the BalanceDecreased event", async () => {
+            await (0, chai_1.expect)(tx)
+                .to.emit(bank, "BalanceDecreased")
+                .withArgs(thirdParty.address, amount);
+        });
+    });
+    describe("DOMAIN_SEPARATOR", () => {
+        it("should be keccak256 of EIP712 domain struct", async () => {
+            const { keccak256 } = hardhat_1.ethers.utils;
+            const { defaultAbiCoder } = hardhat_1.ethers.utils;
+            const { toUtf8Bytes } = hardhat_1.ethers.utils;
+            const expected = keccak256(defaultAbiCoder.encode(["bytes32", "bytes32", "bytes32", "uint256", "address"], [
+                keccak256(toUtf8Bytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")),
+                keccak256(toUtf8Bytes("TBTC Bank")),
+                keccak256(toUtf8Bytes("1")),
+                hardhatNetworkId,
+                bank.address,
+            ]));
+            (0, chai_1.expect)(await bank.DOMAIN_SEPARATOR()).to.equal(expected);
+        });
+    });
+});