@keep-network/tbtc-v2 1.6.0-dev.17 → 1.6.0-dev.18

package/contracts/test/SepoliaLightRelay.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+// ██████████████     ▐████▌     ██████████████
+// ██████████████     ▐████▌     ██████████████
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+//               ▐████▌    ▐████▌
+
+pragma solidity 0.8.17;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../relay/LightRelay.sol";
+
+/// @title Sepolia Light Relay
+/// @notice SepoliaLightRelay is a stub version of LightRelay intended to be
+///         used on the Sepolia test network. It allows to set the relay's
+///         difficulty based on arbitrary Bitcoin headers thus effectively
+///         bypass the validation of difficulties of Bitcoin testnet blocks.
+///         Since difficulty in Bitcoin testnet often falls to `1` it would not
+///         be possible to validate blocks with the real LightRelay.
+/// @dev Notice that SepoliaLightRelay is derived from LightRelay so that the two
+///      contracts have the same API and correct bindings can be generated.
+contract SepoliaLightRelay is LightRelay {
+    using BTCUtils for bytes;
+    using BTCUtils for uint256;
+
+    /// @notice Sets the current and previous difficulty based on the difficulty
+    ///         inferred from the provided Bitcoin headers.
+    function setDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+        onlyOwner
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        currentEpochDifficulty = firstHeaderDiff;
+        prevEpochDifficulty = firstHeaderDiff;
+    }
+}

package/contracts/test/SystemTestRelay.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../bridge/Bridge.sol";
+
+/// @notice Used only for system tests.
+contract SystemTestRelay is IRelay {
+    using BTCUtils for bytes;
+    using BTCUtils for uint256;
+
+    uint256 private currentEpochDifficulty;
+    uint256 private prevEpochDifficulty;
+
+    function setCurrentEpochDifficulty(uint256 _difficulty) external {
+        currentEpochDifficulty = _difficulty;
+    }
+
+    function setPrevEpochDifficulty(uint256 _difficulty) external {
+        prevEpochDifficulty = _difficulty;
+    }
+
+    function setCurrentEpochDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        currentEpochDifficulty = firstHeaderDiff;
+    }
+
+    function setPrevEpochDifficultyFromHeaders(bytes memory bitcoinHeaders)
+        external
+    {
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
+
+        prevEpochDifficulty = firstHeaderDiff;
+    }
+
+    function getCurrentEpochDifficulty()
+        external
+        view
+        override
+        returns (uint256)
+    {
+        return currentEpochDifficulty;
+    }
+
+    function getPrevEpochDifficulty() external view override returns (uint256) {
+        return prevEpochDifficulty;
+    }
+}

package/contracts/test/TestBitcoinTx.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../bridge/BitcoinTx.sol";
+import "../bridge/BridgeState.sol";
+import "../bridge/IRelay.sol";
+
+contract TestBitcoinTx {
+    BridgeState.Storage internal self;
+
+    event ProofValidated(bytes32 txHash);
+
+    constructor(address _relay) {
+        self.relay = IRelay(_relay);
+    }
+
+    function validateProof(
+        BitcoinTx.Info calldata txInfo,
+        BitcoinTx.Proof calldata proof
+    ) external {
+        emit ProofValidated(BitcoinTx.validateProof(self, txInfo, proof));
+    }
+}

package/contracts/test/TestERC20.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol";
+
+contract TestERC20 is ERC20WithPermit {
+    string public constant NAME = "Test ERC20 Token";
+    string public constant SYMBOL = "TT";
+
+    constructor() ERC20WithPermit(NAME, SYMBOL) {}
+}

package/contracts/test/TestERC721.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract TestERC721 is ERC721 {
+    string public constant NAME = "Test ERC721 Token";
+    string public constant SYMBOL = "TT";
+
+    constructor() ERC721(NAME, SYMBOL) {}
+
+    function mint(address to, uint256 tokenId) public {
+        _mint(to, tokenId);
+    }
+}

package/contracts/test/TestEcdsaLib.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "../bridge/EcdsaLib.sol";
+
+// TODO: Rename to EcdsLibStub
+/// @dev This is a contract implemented to test EcdsaLib library directly.
+contract TestEcdsaLib {
+    function compressPublicKey(bytes32 x, bytes32 y)
+        public
+        pure
+        returns (bytes memory)
+    {
+        return EcdsaLib.compressPublicKey(x, y);
+    }
+}

package/contracts/test/TestTBTCDepositor.sol

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity ^0.8.0;
+
+import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
+
+import "../integrator/AbstractTBTCDepositor.sol";
+import "../integrator/IBridge.sol";
+import "../integrator/ITBTCVault.sol";
+
+contract TestTBTCDepositor is AbstractTBTCDepositor {
+    event InitializeDepositReturned(uint256 depositKey);
+
+    event FinalizeDepositReturned(
+        uint256 initialDepositAmount,
+        uint256 tbtcAmount,
+        bytes32 extraData
+    );
+
+    function initialize(address _bridge, address _tbtcVault) external {
+        __AbstractTBTCDepositor_initialize(_bridge, _tbtcVault);
+    }
+
+    function initializeDepositPublic(
+        IBridgeTypes.BitcoinTxInfo calldata fundingTx,
+        IBridgeTypes.DepositRevealInfo calldata reveal,
+        bytes32 extraData
+    ) external {
+        uint256 depositKey = _initializeDeposit(fundingTx, reveal, extraData);
+        emit InitializeDepositReturned(depositKey);
+    }
+
+    function finalizeDepositPublic(uint256 depositKey) external {
+        (
+            uint256 initialDepositAmount,
+            uint256 tbtcAmount,
+            bytes32 extraData
+        ) = _finalizeDeposit(depositKey);
+        emit FinalizeDepositReturned(
+            initialDepositAmount,
+            tbtcAmount,
+            extraData
+        );
+    }
+
+    function calculateTbtcAmountPublic(
+        uint64 depositAmountSat,
+        uint64 depositTreasuryFeeSat
+    ) external view returns (uint256) {
+        return _calculateTbtcAmount(depositAmountSat, depositTreasuryFeeSat);
+    }
+}
+
+contract MockBridge is IBridge {
+    using BTCUtils for bytes;
+
+    mapping(uint256 => IBridgeTypes.DepositRequest) internal _deposits;
+
+    uint64 internal _depositTreasuryFeeDivisor = 50; // 1/50 == 100 bps == 2% == 0.02
+    uint64 internal _depositTxMaxFee = 1000; // 1000 satoshi = 0.00001 BTC
+
+    event DepositRevealed(uint256 depositKey);
+
+    function revealDepositWithExtraData(
+        IBridgeTypes.BitcoinTxInfo calldata fundingTx,
+        IBridgeTypes.DepositRevealInfo calldata reveal,
+        bytes32 extraData
+    ) external {
+        bytes32 fundingTxHash = abi
+            .encodePacked(
+                fundingTx.version,
+                fundingTx.inputVector,
+                fundingTx.outputVector,
+                fundingTx.locktime
+            )
+            .hash256View();
+
+        uint256 depositKey = uint256(
+            keccak256(
+                abi.encodePacked(fundingTxHash, reveal.fundingOutputIndex)
+            )
+        );
+
+        require(
+            _deposits[depositKey].revealedAt == 0,
+            "Deposit already revealed"
+        );
+
+        bytes memory fundingOutput = fundingTx
+            .outputVector
+            .extractOutputAtIndex(reveal.fundingOutputIndex);
+
+        uint64 fundingOutputAmount = fundingOutput.extractValue();
+
+        IBridgeTypes.DepositRequest memory request;
+
+        request.depositor = msg.sender;
+        request.amount = fundingOutputAmount;
+        /* solhint-disable-next-line not-rely-on-time */
+        request.revealedAt = uint32(block.timestamp);
+        request.vault = reveal.vault;
+        request.treasuryFee = _depositTreasuryFeeDivisor > 0
+            ? fundingOutputAmount / _depositTreasuryFeeDivisor
+            : 0;
+        request.sweptAt = 0;
+        request.extraData = extraData;
+
+        _deposits[depositKey] = request;
+
+        emit DepositRevealed(depositKey);
+    }
+
+    function sweepDeposit(uint256 depositKey) public {
+        require(_deposits[depositKey].revealedAt != 0, "Deposit not revealed");
+        require(_deposits[depositKey].sweptAt == 0, "Deposit already swept");
+        /* solhint-disable-next-line not-rely-on-time */
+        _deposits[depositKey].sweptAt = uint32(block.timestamp);
+    }
+
+    function deposits(uint256 depositKey)
+        external
+        view
+        returns (IBridgeTypes.DepositRequest memory)
+    {
+        return _deposits[depositKey];
+    }
+
+    function depositParameters()
+        external
+        view
+        returns (
+            uint64 depositDustThreshold,
+            uint64 depositTreasuryFeeDivisor,
+            uint64 depositTxMaxFee,
+            uint32 depositRevealAheadPeriod
+        )
+    {
+        depositDustThreshold = 0;
+        depositTreasuryFeeDivisor = 0;
+        depositTxMaxFee = _depositTxMaxFee;
+        depositRevealAheadPeriod = 0;
+    }
+
+    function setDepositTreasuryFeeDivisor(uint64 value) external {
+        _depositTreasuryFeeDivisor = value;
+    }
+
+    function setDepositTxMaxFee(uint64 value) external {
+        _depositTxMaxFee = value;
+    }
+}
+
+contract MockTBTCVault is ITBTCVault {
+    struct Request {
+        uint64 requestedAt;
+        uint64 finalizedAt;
+    }
+
+    mapping(uint256 => Request) internal _requests;
+
+    uint32 public optimisticMintingFeeDivisor = 100; // 1%
+
+    function optimisticMintingRequests(uint256 depositKey)
+        external
+        returns (uint64 requestedAt, uint64 finalizedAt)
+    {
+        Request memory request = _requests[depositKey];
+        return (request.requestedAt, request.finalizedAt);
+    }
+
+    function createOptimisticMintingRequest(uint256 depositKey) external {
+        require(
+            _requests[depositKey].requestedAt == 0,
+            "Request already exists"
+        );
+        /* solhint-disable-next-line not-rely-on-time */
+        _requests[depositKey].requestedAt = uint64(block.timestamp);
+    }
+
+    function finalizeOptimisticMintingRequest(uint256 depositKey) public {
+        require(
+            _requests[depositKey].requestedAt != 0,
+            "Request does not exist"
+        );
+        require(
+            _requests[depositKey].finalizedAt == 0,
+            "Request already finalized"
+        );
+        /* solhint-disable-next-line not-rely-on-time */
+        _requests[depositKey].finalizedAt = uint64(block.timestamp);
+    }
+
+    function setOptimisticMintingFeeDivisor(uint32 value) external {
+        optimisticMintingFeeDivisor = value;
+    }
+}

package/contracts/test/WormholeBridgeStub.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+pragma solidity 0.8.17;
+
+import "./TestERC20.sol";
+import "../l2/L2WormholeGateway.sol";
+
+/// @dev Stub contract used in L2WormholeGateway unit tests.
+///      Stub contract is used instead of a smock because of the token transfer
+///      that needs to happen in completeTransferWithPayload function.
+contract WormholeBridgeStub is IWormholeTokenBridge {
+    TestERC20 public wormholeToken;
+
+    uint256 public transferAmount;
+    bytes32 public receiverAddress;
+
+    // Two simple events allowing to assert Wormhole bridge functions are
+    // called.
+    event WormholeBridgeStub_completeTransferWithPayload(bytes encodedVm);
+    event WormholeBridgeStub_transferTokens(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint256 arbiterFee,
+        uint32 nonce
+    );
+    event WormholeBridgeStub_transferTokensWithPayload(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint32 nonce,
+        bytes payload
+    );
+
+    constructor(TestERC20 _wormholeToken) {
+        wormholeToken = _wormholeToken;
+    }
+
+    function completeTransferWithPayload(bytes memory encodedVm)
+        external
+        returns (bytes memory)
+    {
+        emit WormholeBridgeStub_completeTransferWithPayload(encodedVm);
+        wormholeToken.mint(msg.sender, transferAmount);
+
+        // In a real implementation, encodedVm is parsed. To avoid copy-pasting
+        // Wormhole code to this contract and then encoding parmaters in unit
+        // tests, we allow to set the receiver address on the stub contract and
+        // we return it here. The rest of the parameters does not matter.
+        IWormholeTokenBridge.TransferWithPayload memory transfer = IWormholeTokenBridge
+            .TransferWithPayload(
+                1, // payloadID
+                2, // amount
+                0x3000000000000000000000000000000000000000000000000000000000000000, // tokenAddress
+                4, // tokenChain
+                0x5000000000000000000000000000000000000000000000000000000000000000, // to
+                6, // toChain
+                0x7000000000000000000000000000000000000000000000000000000000000000, // fromAddress
+                abi.encode(receiverAddress) // payload
+            );
+
+        return abi.encode(transfer);
+    }
+
+    function transferTokens(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint256 arbiterFee,
+        uint32 nonce
+    ) external payable returns (uint64 sequence) {
+        emit WormholeBridgeStub_transferTokens(
+            token,
+            amount,
+            recipientChain,
+            recipient,
+            arbiterFee,
+            nonce
+        );
+        return 777;
+    }
+
+    function transferTokensWithPayload(
+        address token,
+        uint256 amount,
+        uint16 recipientChain,
+        bytes32 recipient,
+        uint32 nonce,
+        bytes memory payload
+    ) external payable returns (uint64 sequence) {
+        emit WormholeBridgeStub_transferTokensWithPayload(
+            token,
+            amount,
+            recipientChain,
+            recipient,
+            nonce,
+            payload
+        );
+        return 888;
+    }
+
+    function parseTransferWithPayload(bytes memory encoded)
+        external
+        pure
+        returns (IWormholeTokenBridge.TransferWithPayload memory transfer)
+    {
+        return abi.decode(encoded, (IWormholeTokenBridge.TransferWithPayload));
+    }
+
+    function setTransferAmount(uint256 _transferAmount) external {
+        transferAmount = _transferAmount;
+    }
+
+    function setReceiverAddress(bytes32 _receiverAddress) external {
+        receiverAddress = _receiverAddress;
+    }
+
+    // Allows to mint Wormhole tBTC for depositWormholeTbtc unit tests.
+    function mintWormholeToken(address to, uint256 amount) external {
+        wormholeToken.mint(to, amount);
+    }
+}

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@keep-network/tbtc-v2",
-  "version": "1.6.0-dev.17+main.301497dcc676dff18132eda7a381b861ceec3a5d",
+  "version": "1.6.0-dev.18+main.7561ba72c3a0f2b4ede45cd751067bd8d0f8c78e",
   "license": "GPL-3.0-only",
   "files": [
     "artifacts/",
     "build/contracts/",
     "contracts/",
-    "!**/test/",
     "deploy/",
     "export/",
     "tasks/",