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

package/export/test/integration/utils/fixture.js

@@ -0,0 +1,77 @@
+"use strict";
+/* eslint-disable no-await-in-loop */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixture = void 0;
+const smock_1 = require("@defi-wonderland/smock");
+const hardhat_1 = require("hardhat");
+const ecdsa_wallet_registry_1 = require("./ecdsa-wallet-registry");
+const random_beacon_1 = require("./random-beacon");
+const staking_1 = require("./staking");
+const { to1e18 } = hardhat_1.helpers.number;
+// Number of operators to register in the sortition pool
+const numberOfOperators = 110;
+const unnamedSignersOffset = 0;
+const stakeAmount = to1e18(40000);
+// eslint-disable-next-line import/prefer-default-export
+exports.fixture = hardhat_1.deployments.createFixture(async () => {
+    await hardhat_1.deployments.fixture();
+    const { deployer, governance } = await hardhat_1.helpers.signers.getNamedSigners();
+    const tbtc = await hardhat_1.helpers.contracts.getContract("TBTC");
+    const bridge = await hardhat_1.helpers.contracts.getContract("Bridge");
+    const tbtcVault = await hardhat_1.helpers.contracts.getContract("TBTCVault");
+    const walletRegistry = await hardhat_1.helpers.contracts.getContract("WalletRegistry");
+    const t = await hardhat_1.helpers.contracts.getContract("T");
+    const staking = await hardhat_1.helpers.contracts.getContract("TokenStaking");
+    // TODO: Vault registration and upgrade from VendingMachine should be a part
+    // of the deployment scripts.
+    await prepareVault(bridge, tbtcVault, await hardhat_1.helpers.contracts.getContract("VendingMachine"), governance, deployer, deployer);
+    // TODO: INTEGRATE WITH THE REAL BEACON
+    const randomBeacon = await (0, random_beacon_1.fakeRandomBeacon)(walletRegistry);
+    const sortitionPool = await hardhat_1.ethers.getContractAt("SortitionPool", await walletRegistry.sortitionPool());
+    const relay = await smock_1.smock.fake("TestRelay", {
+        address: await (await bridge.contractReferences()).relay,
+    });
+    const signers = (await hardhat_1.helpers.signers.getUnnamedSigners()).slice(unnamedSignersOffset);
+    // We use unique accounts for each staking role for each operator.
+    if (signers.length < numberOfOperators * 5) {
+        throw new Error("not enough unnamed signers; update hardhat network's configuration account count");
+    }
+    for (let i = 0; i < numberOfOperators; i++) {
+        const owner = signers[i];
+        const stakingProvider = signers[1 * numberOfOperators + i];
+        const operator = signers[2 * numberOfOperators + i];
+        const beneficiary = signers[3 * numberOfOperators + i];
+        const authorizer = signers[4 * numberOfOperators + i];
+        await (0, staking_1.stake)(t, staking, stakeAmount, owner, stakingProvider.address, beneficiary.address, authorizer.address);
+        await (0, staking_1.authorizeApplication)(staking, walletRegistry.address, authorizer, stakingProvider.address, stakeAmount);
+        await (0, ecdsa_wallet_registry_1.registerOperator)(walletRegistry, sortitionPool, stakingProvider, operator);
+    }
+    return {
+        deployer,
+        governance,
+        tbtc,
+        bridge,
+        tbtcVault,
+        walletRegistry,
+        staking,
+        randomBeacon,
+        relay,
+    };
+});
+async function prepareVault(bridge, tbtcVault, vendingMachine, governance, vendingMachineUpgradeInitiator, vendingMachineOwner) {
+    // Deployment scripts deploy both `VendingMachine` and `TBTCVault` but they
+    // do not transfer the ownership of `TBTC` token to `TBTCVault`.
+    // We need to do it manually in tests covering `TBTCVault` behavior.
+    // Also, please note that `03_transfer_roles.ts` assigning `VendingMachine`
+    // upgrade initiator role to Keep Technical Wallet is skipped for Hardhat
+    // env deployment. That's why the upgrade initiator and `VendingMachine`
+    // owner is the deployer.
+    await vendingMachine
+        .connect(vendingMachineUpgradeInitiator)
+        .initiateVendingMachineUpgrade(tbtcVault.address);
+    await hardhat_1.helpers.time.increaseTime(await vendingMachine.GOVERNANCE_DELAY());
+    await vendingMachine
+        .connect(vendingMachineOwner)
+        .finalizeVendingMachineUpgrade();
+    await bridge.connect(governance).setVaultStatus(tbtcVault.address, true);
+}

package/export/test/integration/utils/gas.js

@@ -0,0 +1,36 @@
+"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 });
+exports.assertGasUsed = void 0;
+const chai_1 = __importStar(require("chai"));
+const hardhat_1 = require("hardhat");
+const { BigNumber } = hardhat_1.ethers;
+chai_1.default.use(hardhat_1.waffle.solidity);
+// TODO: Move to @keep-network/hardhat-helpers
+// eslint-disable-next-line import/prefer-default-export
+async function assertGasUsed(tx, expectedGasUsed, delta = 1000) {
+    (0, chai_1.expect)((await tx.wait()).gasUsed, "invalid gas used").to.be.closeTo(BigNumber.from(expectedGasUsed), delta);
+}
+exports.assertGasUsed = assertGasUsed;

package/export/test/integration/utils/random-beacon.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.produceRelayEntry = exports.fakeRandomBeacon = void 0;
+const hardhat_1 = require("hardhat");
+const smock_1 = require("@defi-wonderland/smock");
+// eslint-disable-next-line import/prefer-default-export
+async function fakeRandomBeacon(walletRegistry) {
+    const randomBeacon = await smock_1.smock.fake("IRandomBeacon", {
+        address: await walletRegistry.callStatic.randomBeacon(),
+    });
+    await (await hardhat_1.ethers.getSigners())[0].sendTransaction({
+        to: randomBeacon.address,
+        value: hardhat_1.ethers.utils.parseEther("1000"),
+    });
+    return randomBeacon;
+}
+exports.fakeRandomBeacon = fakeRandomBeacon;
+async function produceRelayEntry(walletRegistry, randomBeacon) {
+    const relayEntry = hardhat_1.ethers.utils.randomBytes(32);
+    // eslint-disable-next-line no-underscore-dangle
+    await walletRegistry
+        .connect(randomBeacon.wallet)
+        .__beaconCallback(relayEntry, 0);
+    return relayEntry;
+}
+exports.produceRelayEntry = produceRelayEntry;

package/export/test/integration/utils/staking.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorizeApplication = exports.stake = void 0;
+const hardhat_1 = require("hardhat");
+async function stake(t, staking, stakeAmount, owner, stakingProvider, beneficiary, authorizer) {
+    const { deployer } = await hardhat_1.helpers.signers.getNamedSigners();
+    await t.connect(deployer).mint(await owner.getAddress(), stakeAmount);
+    await t.connect(owner).approve(staking.address, stakeAmount);
+    await staking
+        .connect(owner)
+        .stake(stakingProvider, beneficiary, authorizer, stakeAmount);
+}
+exports.stake = stake;
+async function authorizeApplication(staking, application, authorizer, stakingProvider, stakeAmount) {
+    await staking
+        .connect(authorizer)
+        .increaseAuthorization(stakingProvider, application, stakeAmount);
+}
+exports.authorizeApplication = authorizeApplication;

package/export/test/vault/DonationVault.test.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const chai_1 = require("chai");
+const { createSnapshot, restoreSnapshot } = hardhat_1.helpers.snapshot;
+const fixture = async () => {
+    const [deployer, bridge, account1, account2] = 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);
+    const DonationVault = await hardhat_1.ethers.getContractFactory("DonationVault");
+    const vault = await DonationVault.deploy(bank.address);
+    await vault.deployed();
+    return {
+        bridge,
+        account1,
+        account2,
+        bank,
+        vault,
+    };
+};
+describe("DonationVault", () => {
+    let bridge;
+    let account1;
+    let account2;
+    let bank;
+    let vault;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ bridge, account1, account2, bank, vault } = await hardhat_1.waffle.loadFixture(fixture));
+    });
+    describe("constructor", () => {
+        context("when called with a 0-address bank", () => {
+            it("should revert", async () => {
+                const DonationVault = await hardhat_1.ethers.getContractFactory("DonationVault");
+                await (0, chai_1.expect)(DonationVault.deploy(hardhat_1.ethers.constants.AddressZero)).to.be.revertedWith("Bank can not be the zero address");
+            });
+        });
+        context("when called with correct parameters", () => {
+            it("should set the Bank field", async () => {
+                (0, chai_1.expect)(await vault.bank()).to.equal(bank.address);
+            });
+        });
+    });
+    describe("donate", () => {
+        context("when caller has not enough balance in the bank", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(bridge).increaseBalance(account1.address, 999);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(vault.connect(account1).donate(1000)).to.be.revertedWith("Amount exceeds balance in the bank");
+            });
+        });
+        context("when vault does not have enough allowance for caller's balance", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(bridge).increaseBalance(account1.address, 1000);
+                await bank
+                    .connect(account1)
+                    .increaseBalanceAllowance(vault.address, 999);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(vault.connect(account1).donate(1000)).to.be.revertedWith("Transfer amount exceeds allowance");
+            });
+        });
+        context("when called with correct parameters", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(bridge).increaseBalance(account1.address, 1100);
+                await bank
+                    .connect(account1)
+                    .increaseBalanceAllowance(vault.address, 1100);
+                tx = await vault.connect(account1).donate(1000);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should decrease donor's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(account1.address)).to.be.equal(100);
+            });
+            it("should not increase vault's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.be.equal(0);
+            });
+            it("should emit BalanceDecreased event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceDecreased")
+                    .withArgs(vault.address, 1000);
+            });
+            it("should emit DonationReceived event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(vault, "DonationReceived")
+                    .withArgs(account1.address, 1000);
+            });
+        });
+    });
+    describe("receiveBalanceApproval", () => {
+        context("when called not by the bank", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(vault
+                    .connect(bridge)
+                    .receiveBalanceApproval(account1.address, 1000, [])).to.be.revertedWith("Caller is not the Bank");
+            });
+        });
+        context("when caller has not enough balance in the bank", () => {
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(bridge).increaseBalance(account1.address, 999);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(account1).approveBalanceAndCall(vault.address, 1000, [])).to.be.revertedWith("Amount exceeds balance in the bank");
+            });
+        });
+        context("when called with correct parameters", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                await bank.connect(bridge).increaseBalance(account1.address, 1100);
+                tx = await bank
+                    .connect(account1)
+                    .approveBalanceAndCall(vault.address, 1000, []);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should decrease donor's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(account1.address)).to.be.equal(100);
+            });
+            it("should not increase vault's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.be.equal(0);
+            });
+            it("should emit BalanceDecreased event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceDecreased")
+                    .withArgs(vault.address, 1000);
+            });
+            it("should emit DonationReceived event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(vault, "DonationReceived")
+                    .withArgs(account1.address, 1000);
+            });
+        });
+    });
+    describe("receiveBalanceIncrease", () => {
+        context("when called not by the bank", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(vault
+                    .connect(bridge)
+                    .receiveBalanceIncrease([account1.address], [1000])).to.be.revertedWith("Caller is not the Bank");
+            });
+        });
+        context("when called with no depositors", () => {
+            it("should revert", async () => {
+                await (0, chai_1.expect)(bank.connect(bridge).increaseBalanceAndCall(vault.address, [], [])).to.be.revertedWith("No depositors specified");
+            });
+        });
+        context("when called with correct parameters", () => {
+            let tx;
+            before(async () => {
+                await createSnapshot();
+                tx = await bank
+                    .connect(bridge)
+                    .increaseBalanceAndCall(vault.address, [account1.address, account2.address], [1000, 2000]);
+            });
+            after(async () => {
+                await restoreSnapshot();
+            });
+            it("should not increase depositors' balances", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(account1.address)).to.be.equal(0);
+                (0, chai_1.expect)(await bank.balanceOf(account2.address)).to.be.equal(0);
+            });
+            it("should not increase vault's balance", async () => {
+                (0, chai_1.expect)(await bank.balanceOf(vault.address)).to.be.equal(0);
+            });
+            it("should emit BalanceDecreased event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(bank, "BalanceDecreased")
+                    .withArgs(vault.address, 3000);
+            });
+            it("should emit DonationReceived event", async () => {
+                await (0, chai_1.expect)(tx)
+                    .to.emit(vault, "DonationReceived")
+                    .withArgs(account1.address, 1000);
+                await (0, chai_1.expect)(tx)
+                    .to.emit(vault, "DonationReceived")
+                    .withArgs(account2.address, 2000);
+            });
+        });
+    });
+});