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

package/export/test/bridge/EcdsaLib.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const hardhat_1 = require("hardhat");
+describe("EcdsaLib", () => {
+    let ecdsaLib;
+    before(async () => {
+        const EcdsaLib = await hardhat_1.ethers.getContractFactory("TestEcdsaLib");
+        ecdsaLib = await EcdsaLib.deploy();
+    });
+    describe("compressPublicKey", async () => {
+        context("with valid uncompressed public key", async () => {
+            const testData = [
+                {
+                    testName: "with even Y",
+                    publicKeyX: "0x50863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352",
+                    publicKeyY: "0x2cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6",
+                    expectedCompressedPublicKey: "0x0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352",
+                },
+                {
+                    testName: "with odd Y",
+                    publicKeyX: "0x2a574ea59cae80b09d6ba415746e9b031abfbe83f149b43b37be035b87164872",
+                    publicKeyY: "0x0336c5eb647e891c98261c57c13098fa6ae68221363c68ff15841b86dad60241",
+                    expectedCompressedPublicKey: "0x032a574ea59cae80b09d6ba415746e9b031abfbe83f149b43b37be035b87164872",
+                },
+                {
+                    testName: "with leading zeros",
+                    publicKeyX: "0x00003ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352",
+                    publicKeyY: "0x000070243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c582ba6",
+                    expectedCompressedPublicKey: "0x0200003ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b2352",
+                },
+                {
+                    testName: "with trailing zeros",
+                    publicKeyX: "0x50863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b0000",
+                    publicKeyY: "0x2cd470243453a299fa9e77237716103abc11a1df38855ed6f2ee187e9c580000",
+                    expectedCompressedPublicKey: "0x0250863ad64a87ae8a2fe83c1af1a8403cb53f53e486d8511dad8a04887e5b0000",
+                },
+            ];
+            testData.forEach((test) => {
+                it(test.testName, async () => {
+                    (0, chai_1.expect)(await ecdsaLib.compressPublicKey(test.publicKeyX, test.publicKeyY)).to.be.equal(test.expectedCompressedPublicKey);
+                });
+            });
+        });
+    });
+});

package/export/test/bridge/Heartbeat.test.js

@@ -0,0 +1,77 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const hardhat_1 = require("hardhat");
+describe("Heartbeat", () => {
+    let heartbeat;
+    before(async () => {
+        const HeartbeatStub = await hardhat_1.ethers.getContractFactory("HeartbeatStub");
+        heartbeat = await HeartbeatStub.deploy();
+    });
+    context("when the message is empty", () => {
+        it("should return false", async () => {
+            const message = "0x";
+            (0, chai_1.expect)(await heartbeat.isValidHeartbeatMessage(message)).to.be.false;
+        });
+    });
+    context("when the message has less than 16 bytes", () => {
+        it("should return false", async () => {
+            // 15 bytes
+            const message = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
+            (0, chai_1.expect)(await heartbeat.isValidHeartbeatMessage(message)).to.be.false;
+        });
+    });
+    context("when the message has more than 16 bytes", () => {
+        it("should return false", async () => {
+            // 17 bytes
+            const message = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
+            (0, chai_1.expect)(await heartbeat.isValidHeartbeatMessage(message)).to.be.false;
+        });
+    });
+    context("when the message has 16 bytes", () => {
+        context("when the message does not have the required prefix", () => {
+            it("should return false", async () => {
+                const messages = [
+                    "0x00000000000000000000000000000000",
+                    "0xFF000000000000000000000000000000",
+                    "0xFFFF0000000000000000000000000000",
+                    "0xFFFFFF00000000000000000000000000",
+                    "0xFFFFFFFF000000000000000000000000",
+                    "0xFFFFFFFFFF0000000000000000000000",
+                    "0xFFFFFFFFFFFF00000000000000000000",
+                    "0xFFFFFFFFFFFFFF000000000000000000",
+                    "0x11111111111111111111111111111111",
+                    "0xFF111111111111111111111111111111",
+                    "0xFFFF1111111111111111111111111111",
+                    "0xFFFFFF11111111111111111111111111",
+                    "0xFFFFFFFF111111111111111111111111",
+                    "0xFFFFFFFFFF1111111111111111111111",
+                    "0xFFFFFFFFFFFF11111111111111111111",
+                    "0xFFFFFFFFFFFFFF111111111111111111",
+                    "0xFFFFFFFFFFFFFF0FFFFFFFFFFFFFFFFF",
+                    "0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+                ];
+                for (let i = 0; i < messages.length; i++) {
+                    // eslint-disable-next-line no-await-in-loop
+                    (0, chai_1.expect)(await heartbeat.isValidHeartbeatMessage(messages[i])).to.be
+                        .false;
+                }
+            });
+        });
+        context("when the message has the required prefix", () => {
+            it("should return true", async () => {
+                const messages = [
+                    "0xFFFFFFFFFFFFFFFF0000000000000000",
+                    "0xFFFFFFFFFFFFFFFF1111111111111111",
+                    "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+                ];
+                for (let i = 0; i < messages.length; i++) {
+                    // eslint-disable-next-line no-await-in-loop
+                    (0, chai_1.expect)(await heartbeat.isValidHeartbeatMessage(messages[i])).to.be
+                        .true;
+                }
+            });
+        });
+    });
+});

package/export/test/bridge/VendingMachine.Upgrade.test.js

@@ -0,0 +1,160 @@
+"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 deposit_sweep_1 = require("../data/deposit-sweep");
+const { to1e18 } = hardhat_1.helpers.number;
+const { increaseTime, lastBlockTime } = hardhat_1.helpers.time;
+// Test covering `VendingMachine` -> `TBTCVault` upgrade process.
+//
+// Step #1 - TBTC v1 transfer
+//   TBTC v1 is transferred from `VendingMachine` to `TBTCVault` along with
+//   TBTC v2 token ownership.
+//
+// Step #2 - TBTC v1 withdrawal
+//   Governance withdraws TBTC v1 from `VendingMachine` *somewhere*.
+//   Governance unmints TBTC v1 to BTC *somehow*.
+//
+// Step #3 - BTC deposits
+//   Governance deposits BTC to `TBTCVault`.
+//
+// Step #4 - functioning system
+//   The system works. Users can mint and unmint TBTC v2.
+describe("VendingMachine - Upgrade", () => {
+    let deployer;
+    let governance;
+    let account1;
+    let account2;
+    let tbtcV1;
+    let tbtc;
+    let tbtcVault;
+    let bridge;
+    let bank;
+    let vendingMachine;
+    let relay;
+    before(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
+        ;
+        ({ deployer, governance } = await hardhat_1.helpers.signers.getNamedSigners());
+        [account1, account2] = await hardhat_1.helpers.signers.getUnnamedSigners();
+        ({ tbtcVault, tbtc, vendingMachine, bank, bridge, relay } =
+            await hardhat_1.waffle.loadFixture(bridge_1.default));
+        // Set the deposit dust threshold to 0.0001 BTC, i.e. 100x smaller than
+        // the initial value in the Bridge in order to save test Bitcoins.
+        await bridge.setDepositDustThreshold(10000);
+        await bridge.connect(governance).setVaultStatus(tbtcVault.address, true);
+        tbtcV1 = await hardhat_1.helpers.contracts.getContract("TBTCToken");
+        // Two accounts with 10 TBTC v1 each wrap their holdings to TBTC v2.
+        const initialTbtcBalance = to1e18(10);
+        await tbtcV1.connect(deployer).mint(account1.address, initialTbtcBalance);
+        await tbtcV1.connect(deployer).mint(account2.address, initialTbtcBalance);
+        await tbtcV1
+            .connect(account1)
+            .approveAndCall(vendingMachine.address, initialTbtcBalance, []);
+        await tbtcV1
+            .connect(account2)
+            .approveAndCall(vendingMachine.address, initialTbtcBalance, []);
+        // 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(deployer)
+            .initiateVendingMachineUpgrade(tbtcVault.address);
+        await increaseTime(await vendingMachine.GOVERNANCE_DELAY());
+        await vendingMachine.connect(deployer).finalizeVendingMachineUpgrade();
+    });
+    describe("upgrade process", () => {
+        // Two accounts with 10 TBTC v1 each wrap their holdings to TBTC v2.
+        // See the main `before`.
+        const totalTbtcV1Balance = to1e18(20);
+        describe("step#1 - TBTC v1 transfer", () => {
+            it("should transfer all TBTC v1 to TBTCVault", async () => {
+                (0, chai_1.expect)(await tbtcV1.balanceOf(vendingMachine.address)).to.equal(to1e18(0));
+                (0, chai_1.expect)(await tbtcV1.balanceOf(tbtcVault.address)).to.equal(totalTbtcV1Balance);
+            });
+        });
+        describe("step#2 - TBTC v1 withdrawal", () => {
+            it("should let the governance withdraw TBTC v1 from TBTCVault", async () => {
+                await tbtcVault
+                    .connect(governance)
+                    .recoverERC20(tbtcV1.address, governance.address, totalTbtcV1Balance);
+                (0, chai_1.expect)(await tbtcV1.balanceOf(tbtcVault.address)).to.equal(0);
+                (0, chai_1.expect)(await tbtcV1.balanceOf(governance.address)).to.equal(totalTbtcV1Balance);
+            });
+        });
+        describe("step#3 - BTC deposit", () => {
+            before(async () => {
+                const data = JSON.parse(JSON.stringify(deposit_sweep_1.SingleP2SHDeposit));
+                const { fundingTx, reveal } = data.deposits[0]; // it's a single deposit
+                reveal.vault = tbtcVault.address;
+                // Simulate the wallet is a Live one and is known in the system.
+                await bridge.setWallet(reveal.walletPubKeyHash, {
+                    ecdsaWalletID: hardhat_1.ethers.constants.HashZero,
+                    mainUtxoHash: hardhat_1.ethers.constants.HashZero,
+                    pendingRedemptionsValue: 0,
+                    createdAt: await lastBlockTime(),
+                    movingFundsRequestedAt: 0,
+                    closingStartedAt: 0,
+                    pendingMovedFundsSweepRequestsCount: 0,
+                    state: fixtures_1.walletState.Live,
+                    movingFundsTargetWalletsCommitmentHash: hardhat_1.ethers.constants.HashZero,
+                });
+                await bridge.revealDeposit(fundingTx, reveal);
+                relay.getCurrentEpochDifficulty.returns(data.chainDifficulty);
+                relay.getPrevEpochDifficulty.returns(data.chainDifficulty);
+                await bridge.submitDepositSweepProof(data.sweepTx, data.sweepProof, data.mainUtxo, tbtcVault.address);
+            });
+            it("should let the governance donate TBTCVault", async () => {
+                // The sum of sweep tx inputs is 20000 satoshi. The output
+                // value is 18500 so the transaction fee is 1500. There is
+                // only one deposit so it incurs the entire transaction fee.
+                // The deposit should also incur the treasury fee whose
+                // initial value is 0.05% of the deposited amount so the
+                // final depositor balance should be cut by 10 satoshi.
+                const totalWalletBtcBalance = 18490;
+                (0, chai_1.expect)(await bank.balanceOf(tbtcVault.address)).to.equal(totalWalletBtcBalance);
+            });
+        });
+        describe("step#4 - functioning system", () => {
+            it("should let TBTC v2 holders unmint their tokens", async () => {
+                const initialWalletBtcBalance = 18490;
+                const unmintedAmount1 = 7000;
+                const unmintedAmount2 = 1000;
+                await tbtc.connect(account1).approve(tbtcVault.address, unmintedAmount1);
+                await tbtcVault.connect(account1).unmint(unmintedAmount1);
+                await tbtc.connect(account2).approve(tbtcVault.address, unmintedAmount2);
+                await tbtcVault.connect(account2).unmint(unmintedAmount2);
+                (0, chai_1.expect)(await bank.balanceOf(account1.address)).to.equal(unmintedAmount1);
+                (0, chai_1.expect)(await bank.balanceOf(account2.address)).to.equal(unmintedAmount2);
+                (0, chai_1.expect)(await bank.balanceOf(tbtcVault.address)).to.equal(initialWalletBtcBalance - unmintedAmount1 - unmintedAmount2);
+            });
+            it("should let Bank balance holders mint TBTC v2", async () => {
+                const initialWalletBtcBalance = 10490; // 18490 - 7000 - 1000
+                const mintedAmount1 = 600;
+                const mintedAmount2 = 100;
+                const initialTbtcBalance1 = await tbtc.balanceOf(account1.address);
+                const initialTbtcBalance2 = await tbtc.balanceOf(account2.address);
+                await bank
+                    .connect(account1)
+                    .approveBalance(tbtcVault.address, mintedAmount1);
+                await tbtcVault.connect(account1).mint(mintedAmount1);
+                await bank
+                    .connect(account2)
+                    .approveBalance(tbtcVault.address, mintedAmount2);
+                await tbtcVault.connect(account2).mint(mintedAmount2);
+                (0, chai_1.expect)(await tbtc.balanceOf(account1.address)).to.equal(initialTbtcBalance1.add(mintedAmount1));
+                (0, chai_1.expect)(await tbtc.balanceOf(account2.address)).to.equal(initialTbtcBalance2.add(mintedAmount2));
+                (0, chai_1.expect)(await bank.balanceOf(tbtcVault.address)).to.equal(initialWalletBtcBalance + mintedAmount1 + mintedAmount2);
+            });
+        });
+    });
+});