@keep-network/tbtc-v2 0.1.1-dev.14 → 0.1.1-dev.17

package/contracts/bridge/Bridge.sol

@@ -13,15 +13,13 @@
 //               ▐████▌    ▐████▌
 //               ▐████▌    ▐████▌
 
-pragma solidity 0.8.4;
+pragma solidity ^0.8.9;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
 
 import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
 import {BytesLib} from "@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol";
-import {
-    ValidateSPV
-} from "@keep-network/bitcoin-spv-sol/contracts/ValidateSPV.sol";
+import {ValidateSPV} from "@keep-network/bitcoin-spv-sol/contracts/ValidateSPV.sol";
 
 import "../bank/Bank.sol";
 import "./BitcoinTx.sol";
@@ -191,15 +189,21 @@ contract Bridge is Ownable {
 
     /// TODO: Make it governable.
     /// @notice The minimal amount that can be requested for redemption.
-    ///         Value of this parameter should be always bigger than the sum
-    ///         of `redemptionTreasuryFee` and `redemptionTxMaxFee` to make
-    ///         redemptions possible.
+    ///         Value of this parameter must take into account the value of
+    ///         `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`
+    ///         parameters in order to make requests that can incur the
+    ///         treasury and transaction fee and still satisfy the redeemer.
     uint64 public redemptionDustThreshold;
 
     /// TODO: Make it governable.
-    /// @notice Amount of TBTC that is taken from each redemption request and
-    ///         transferred to the treasury upon successful request finalization.
-    uint64 public redemptionTreasuryFee;
+    /// @notice Divisor used to compute the treasury fee taken from each
+    ///         redemption request and transferred to the treasury upon
+    ///         successful request finalization. That fee is computed as follows:
+    ///         `treasuryFee = requestedAmount / redemptionTreasuryFeeDivisor`
+    ///         For example, if the treasury fee needs to be 2% of each
+    ///         redemption request, the `redemptionTreasuryFeeDivisor` should
+    ///         be set to `50` because `1/50 = 0.02 = 2%`.
+    uint64 public redemptionTreasuryFeeDivisor;
 
     /// TODO: Make it governable.
     /// @notice Maximum amount of BTC transaction fee that can be incurred by
@@ -336,7 +340,7 @@ contract Bridge is Ownable {
 
         // TODO: Revisit initial values.
         redemptionDustThreshold = 1000000; // 1000000 satoshi = 0.01 BTC
-        redemptionTreasuryFee = 100000; // 100000 satoshi
+        redemptionTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005
         redemptionTxMaxFee = 1000; // 1000 satoshi
         redemptionTimeout = 172800; // 48 hours
     }
@@ -407,39 +411,37 @@ contract Bridge is Ownable {
         // TODO: Validate if `walletPubKeyHash` is a known and active wallet.
         // TODO: Should we enforce a specific locktime at contract level?
 
-        bytes memory expectedScript =
-            abi.encodePacked(
-                hex"14", // Byte length of depositor Ethereum address.
-                reveal.depositor,
-                hex"75", // OP_DROP
-                hex"08", // Byte length of blinding factor value.
-                reveal.blindingFactor,
-                hex"75", // OP_DROP
-                hex"76", // OP_DUP
-                hex"a9", // OP_HASH160
-                hex"14", // Byte length of a compressed Bitcoin public key hash.
-                reveal.walletPubKeyHash,
-                hex"87", // OP_EQUAL
-                hex"63", // OP_IF
-                hex"ac", // OP_CHECKSIG
-                hex"67", // OP_ELSE
-                hex"76", // OP_DUP
-                hex"a9", // OP_HASH160
-                hex"14", // Byte length of a compressed Bitcoin public key hash.
-                reveal.refundPubKeyHash,
-                hex"88", // OP_EQUALVERIFY
-                hex"04", // Byte length of refund locktime value.
-                reveal.refundLocktime,
-                hex"b1", // OP_CHECKLOCKTIMEVERIFY
-                hex"75", // OP_DROP
-                hex"ac", // OP_CHECKSIG
-                hex"68" // OP_ENDIF
-            );
+        bytes memory expectedScript = abi.encodePacked(
+            hex"14", // Byte length of depositor Ethereum address.
+            reveal.depositor,
+            hex"75", // OP_DROP
+            hex"08", // Byte length of blinding factor value.
+            reveal.blindingFactor,
+            hex"75", // OP_DROP
+            hex"76", // OP_DUP
+            hex"a9", // OP_HASH160
+            hex"14", // Byte length of a compressed Bitcoin public key hash.
+            reveal.walletPubKeyHash,
+            hex"87", // OP_EQUAL
+            hex"63", // OP_IF
+            hex"ac", // OP_CHECKSIG
+            hex"67", // OP_ELSE
+            hex"76", // OP_DUP
+            hex"a9", // OP_HASH160
+            hex"14", // Byte length of a compressed Bitcoin public key hash.
+            reveal.refundPubKeyHash,
+            hex"88", // OP_EQUALVERIFY
+            hex"04", // Byte length of refund locktime value.
+            reveal.refundLocktime,
+            hex"b1", // OP_CHECKLOCKTIMEVERIFY
+            hex"75", // OP_DROP
+            hex"ac", // OP_CHECKSIG
+            hex"68" // OP_ENDIF
+        );
 
-        bytes memory fundingOutput =
-            fundingTx.outputVector.extractOutputAtIndex(
-                reveal.fundingOutputIndex
-            );
+        bytes memory fundingOutput = fundingTx
+            .outputVector
+            .extractOutputAtIndex(reveal.fundingOutputIndex);
         bytes memory fundingOutputHash = fundingOutput.extractHash();
 
         if (fundingOutputHash.length == 20) {
@@ -467,31 +469,22 @@ contract Bridge is Ownable {
         }
 
         // Resulting TX hash is in native Bitcoin little-endian format.
-        bytes32 fundingTxHash =
-            abi
-                .encodePacked(
-                fundingTx
-                    .version,
-                fundingTx
-                    .inputVector,
-                fundingTx
-                    .outputVector,
-                fundingTx
-                    .locktime
+        bytes32 fundingTxHash = abi
+            .encodePacked(
+                fundingTx.version,
+                fundingTx.inputVector,
+                fundingTx.outputVector,
+                fundingTx.locktime
             )
-                .hash256View();
+            .hash256View();
 
-        DepositRequest storage deposit =
-            deposits[
-                uint256(
-                    keccak256(
-                        abi.encodePacked(
-                            fundingTxHash,
-                            reveal.fundingOutputIndex
-                        )
-                    )
+        DepositRequest storage deposit = deposits[
+            uint256(
+                keccak256(
+                    abi.encodePacked(fundingTxHash, reveal.fundingOutputIndex)
                 )
-            ];
+            )
+        ];
         require(deposit.revealedAt == 0, "Deposit already revealed");
 
         uint64 fundingOutputAmount = fundingOutput.extractValue();
@@ -569,16 +562,21 @@ contract Bridge is Ownable {
 
         // Process sweep transaction output and extract its target wallet
         // public key hash and value.
-        (bytes20 walletPubKeyHash, uint64 sweepTxOutputValue) =
-            processSweepTxOutput(sweepTx.outputVector);
+        (
+            bytes20 walletPubKeyHash,
+            uint64 sweepTxOutputValue
+        ) = processSweepTxOutput(sweepTx.outputVector);
 
         // TODO: Validate if `walletPubKeyHash` is a known and active wallet.
 
         // Check if the main UTXO for given wallet exists. If so, validate
         // passed main UTXO data against the stored hash and use them for
         // further processing. If no main UTXO exists, use empty data.
-        BitcoinTx.UTXO memory resolvedMainUtxo =
-            BitcoinTx.UTXO(bytes32(0), 0, 0);
+        BitcoinTx.UTXO memory resolvedMainUtxo = BitcoinTx.UTXO(
+            bytes32(0),
+            0,
+            0
+        );
         bytes32 mainUtxoHash = mainUtxos[walletPubKeyHash];
         if (mainUtxoHash != bytes32(0)) {
             require(
@@ -655,15 +653,11 @@ contract Bridge is Ownable {
 
         txHash = abi
             .encodePacked(
-            txInfo
-                .version,
-            txInfo
-                .inputVector,
-            txInfo
-                .outputVector,
-            txInfo
-                .locktime
-        )
+                txInfo.version,
+                txInfo.inputVector,
+                txInfo.outputVector,
+                txInfo.locktime
+            )
             .hash256View();
 
         checkProofFromTxHash(txHash, proof);
@@ -703,8 +697,9 @@ contract Bridge is Ownable {
         uint256 requestedDiff = 0;
         uint256 currentDiff = relay.getCurrentEpochDifficulty();
         uint256 previousDiff = relay.getPrevEpochDifficulty();
-        uint256 firstHeaderDiff =
-            bitcoinHeaders.extractTarget().calculateDifficulty();
+        uint256 firstHeaderDiff = bitcoinHeaders
+            .extractTarget()
+            .calculateDifficulty();
 
         if (firstHeaderDiff == currentDiff) {
             requestedDiff = currentDiff;
@@ -826,8 +821,10 @@ contract Bridge is Ownable {
         // Determining the total number of sweep transaction inputs in the same
         // way as for number of outputs. See `BitcoinTx.inputVector` docs for
         // more details.
-        (uint256 inputsCompactSizeUintLength, uint256 inputsCount) =
-            sweepTxInputVector.parseVarInt();
+        (
+            uint256 inputsCompactSizeUintLength,
+            uint256 inputsCount
+        ) = sweepTxInputVector.parseVarInt();
 
         // To determine the first input starting index, we must jump over
         // the compactSize uint which prepends the input vector. One byte
@@ -865,14 +862,11 @@ contract Bridge is Ownable {
                 uint256 inputLength
             ) = parseTxInputAt(sweepTxInputVector, inputStartingIndex);
 
-            DepositRequest storage deposit =
-                deposits[
-                    uint256(
-                        keccak256(
-                            abi.encodePacked(outpointTxHash, outpointIndex)
-                        )
-                    )
-                ];
+            DepositRequest storage deposit = deposits[
+                uint256(
+                    keccak256(abi.encodePacked(outpointTxHash, outpointIndex))
+                )
+            ];
 
             if (deposit.revealedAt != 0) {
                 // If we entered here, that means the input was identified as
@@ -982,7 +976,7 @@ contract Bridge is Ownable {
     ///        on the redeemer output script will be always lower than this value
     ///        since the treasury and Bitcoin transaction fees must be incurred.
     ///        The minimal amount satisfying the request can be computed as:
-    ///        `amount - redemptionTreasuryFee - redemptionTxMaxFee`.
+    ///        `amount - (amount / redemptionTreasuryFeeDivisor) - redemptionTxMaxFee`.
     ///        Fees values are taken at the moment of request creation.
     /// @dev Requirements:
     ///      - Wallet behind `walletPubKeyHash` must be active
@@ -1039,8 +1033,9 @@ contract Bridge is Ownable {
         // is proper. Worth to note `extractHash` ignores the value at all
         // so this is why we can use 0 safely. This way of validation is the
         // same as in tBTC v1.
-        bytes memory redeemerOutputScriptPayload =
-            abi.encodePacked(bytes8(0), redeemerOutputScript).extractHash();
+        bytes memory redeemerOutputScriptPayload = abi
+            .encodePacked(bytes8(0), redeemerOutputScript)
+            .extractHash();
         require(
             redeemerOutputScriptPayload.length > 0,
             "Redeemer output script must be a standard type"
@@ -1062,12 +1057,9 @@ contract Bridge is Ownable {
         // and redeemer output script pair. That means there can be only one
         // request asking for redemption from the given wallet to the given
         // BTC script at the same time.
-        uint256 redemptionKey =
-            uint256(
-                keccak256(
-                    abi.encodePacked(walletPubKeyHash, redeemerOutputScript)
-                )
-            );
+        uint256 redemptionKey = uint256(
+            keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))
+        );
 
         // Check if given redemption key is not used by a pending redemption.
         // There is no need to check for existence in `timedOutRedemptions`
@@ -1079,7 +1071,12 @@ contract Bridge is Ownable {
             "There is a pending redemption request from this wallet to the same address"
         );
 
-        uint64 treasuryFee = redemptionTreasuryFee;
+        // No need to check whether `amount - treasuryFee - txMaxFee > 0`
+        // since the `redemptionDustThreshold` should force that condition
+        // to be always true.
+        uint64 treasuryFee = redemptionTreasuryFeeDivisor > 0
+            ? amount / redemptionTreasuryFeeDivisor
+            : 0;
         uint64 txMaxFee = redemptionTxMaxFee;
 
         // The main wallet UTXO's value doesn't include all pending redemptions.
@@ -1175,8 +1172,10 @@ contract Bridge is Ownable {
         // can assume the transaction happened on Bitcoin chain and has
         // a sufficient number of confirmations as determined by
         // `txProofDifficultyFactor` constant.
-        bytes32 redemptionTxHash =
-            validateBitcoinTxProof(redemptionTx, redemptionProof);
+        bytes32 redemptionTxHash = validateBitcoinTxProof(
+            redemptionTx,
+            redemptionProof
+        );
 
         // Perform validation of the redemption transaction input. Specifically,
         // check if it refers to the expected wallet's main UTXO.
@@ -1195,11 +1194,10 @@ contract Bridge is Ownable {
 
         // Process redemption transaction outputs to extract some info required
         // for further processing.
-        RedemptionTxOutputsInfo memory outputsInfo =
-            processRedemptionTxOutputs(
-                redemptionTx.outputVector,
-                walletPubKeyHash
-            );
+        RedemptionTxOutputsInfo memory outputsInfo = processRedemptionTxOutputs(
+            redemptionTx.outputVector,
+            walletPubKeyHash
+        );
 
         if (outputsInfo.changeValue > 0) {
             // If the change value is grater than zero, it means the change
@@ -1263,8 +1261,10 @@ contract Bridge is Ownable {
 
         // Assert that the single redemption transaction input actually
         // refers to the wallet's main UTXO.
-        (bytes32 redemptionTxOutpointTxHash, uint32 redemptionTxOutpointIndex) =
-            processRedemptionTxInput(redemptionTxInputVector);
+        (
+            bytes32 redemptionTxOutpointTxHash,
+            uint32 redemptionTxOutpointIndex
+        ) = processRedemptionTxInput(redemptionTxInputVector);
         require(
             mainUtxo.txHash == redemptionTxOutpointTxHash &&
                 mainUtxo.txOutputIndex == redemptionTxOutpointIndex,
@@ -1339,8 +1339,10 @@ contract Bridge is Ownable {
         // Determining the total number of redemption transaction outputs in
         // the same way as for number of inputs. See `BitcoinTx.outputVector`
         // docs for more details.
-        (uint256 outputsCompactSizeUintLength, uint256 outputsCount) =
-            redemptionTxOutputVector.parseVarInt();
+        (
+            uint256 outputsCompactSizeUintLength,
+            uint256 outputsCount
+        ) = redemptionTxOutputVector.parseVarInt();
 
         // To determine the first output starting index, we must jump over
         // the compactSize uint which prepends the output vector. One byte
@@ -1364,13 +1366,13 @@ contract Bridge is Ownable {
         // save on gas. Both scripts have a strict format defined by Bitcoin.
         //
         // The P2PKH script has format <0x1976a914> <20-byte PKH> <0x88ac>.
-        bytes32 walletP2PKHScriptKeccak =
-            keccak256(
-                abi.encodePacked(hex"1976a914", walletPubKeyHash, hex"88ac")
-            );
+        bytes32 walletP2PKHScriptKeccak = keccak256(
+            abi.encodePacked(hex"1976a914", walletPubKeyHash, hex"88ac")
+        );
         // The P2WPKH script has format <0x160014> <20-byte PKH>.
-        bytes32 walletP2WPKHScriptKeccak =
-            keccak256(abi.encodePacked(hex"160014", walletPubKeyHash));
+        bytes32 walletP2WPKHScriptKeccak = keccak256(
+            abi.encodePacked(hex"160014", walletPubKeyHash)
+        );
 
         // Helper variable that counts the number of processed redemption
         // outputs. Redemptions can be either pending or reported as timed out.
@@ -1383,15 +1385,12 @@ contract Bridge is Ownable {
             // TODO: Check if we can optimize gas costs by adding
             //       `extractValueAt` and `extractHashAt` in `bitcoin-spv-sol`
             //       in order to avoid allocating bytes in memory.
-            uint256 outputLength =
-                redemptionTxOutputVector.determineOutputLengthAt(
-                    outputStartingIndex
-                );
-            bytes memory output =
-                redemptionTxOutputVector.slice(
-                    outputStartingIndex,
-                    outputLength
-                );
+            uint256 outputLength = redemptionTxOutputVector
+                .determineOutputLengthAt(outputStartingIndex);
+            bytes memory output = redemptionTxOutputVector.slice(
+                outputStartingIndex,
+                outputLength
+            );
 
             // Extract the value from given output.
             uint64 outputValue = output.extractValue();
@@ -1414,24 +1413,22 @@ contract Bridge is Ownable {
                 // If we entered here, that the means the given output is
                 // supposed to represent a redemption. Build the redemption key
                 // to perform that check.
-                uint256 redemptionKey =
-                    uint256(
-                        keccak256(
-                            abi.encodePacked(walletPubKeyHash, outputScript)
-                        )
-                    );
+                uint256 redemptionKey = uint256(
+                    keccak256(abi.encodePacked(walletPubKeyHash, outputScript))
+                );
 
                 if (pendingRedemptions[redemptionKey].requestedAt != 0) {
                     // If we entered here, that means the output was identified
                     // as a pending redemption request.
-                    RedemptionRequest storage request =
-                        pendingRedemptions[redemptionKey];
+                    RedemptionRequest storage request = pendingRedemptions[
+                        redemptionKey
+                    ];
                     // Compute the request's redeemable amount as the requested
                     // amount reduced by the treasury fee. The request's
                     // minimal amount is then the redeemable amount reduced by
                     // the maximum transaction fee.
-                    uint64 redeemableAmount =
-                        request.requestedAmount - request.treasuryFee;
+                    uint64 redeemableAmount = request.requestedAmount -
+                        request.treasuryFee;
                     // Output value must fit between the request's redeemable
                     // and minimal amounts to be deemed valid.
                     require(
@@ -1460,16 +1457,17 @@ contract Bridge is Ownable {
                     // then bypass this output and process the subsequent
                     // ones. That also means the wallet was already punished
                     // for the inactivity. Otherwise, just revert.
-                    RedemptionRequest storage request =
-                        timedOutRedemptions[redemptionKey];
+                    RedemptionRequest storage request = timedOutRedemptions[
+                        redemptionKey
+                    ];
 
                     require(
                         request.requestedAt != 0,
                         "Output is a non-requested redemption"
                     );
 
-                    uint64 redeemableAmount =
-                        request.requestedAmount - request.treasuryFee;
+                    uint64 redeemableAmount = request.requestedAmount -
+                        request.treasuryFee;
 
                     require(
                         redeemableAmount - request.txMaxFee <= outputValue &&

package/contracts/bridge/VendingMachine.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.4;
+pragma solidity ^0.8.9;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

package/contracts/token/TBTC.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.4;
+pragma solidity ^0.8.9;
 
 import "@thesis/solidity-contracts/contracts/token/ERC20WithPermit.sol";
 import "@thesis/solidity-contracts/contracts/token/MisfundRecovery.sol";

package/contracts/vault/IVault.sol

@@ -13,7 +13,7 @@
 //               ▐████▌    ▐████▌
 //               ▐████▌    ▐████▌
 
-pragma solidity 0.8.4;
+pragma solidity ^0.8.9;
 
 /// @title Bank Vault interface
 /// @notice `IVault` is an interface for a smart contract consuming Bank

package/contracts/vault/TBTCVault.sol

@@ -13,7 +13,7 @@
 //               ▐████▌    ▐████▌
 //               ▐████▌    ▐████▌
 
-pragma solidity 0.8.4;
+pragma solidity ^0.8.9;
 
 import "./IVault.sol";
 import "../bank/Bank.sol";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keep-network/tbtc-v2",
-  "version": "0.1.1-dev.14+main.73fcd4832ad1a1cea43d9826b49f634453337f24",
+  "version": "0.1.1-dev.17+main.045b8fe8e838ba8ae100b838df4f0558df419754",
   "license": "MIT",
   "files": [
     "artifacts/",
@@ -45,17 +45,16 @@
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.10.5",
     "chai": "^4.3.4",
-    "eslint": "^7.30.0",
-    "eslint-config-keep": "github:keep-network/eslint-config-keep#0c27ade",
-    "eslint-plugin-import": "^2.18.2",
+    "eslint": "^7.32.0",
     "ethereum-waffle": "^3.4.0",
     "ethers": "^5.4.7",
     "hardhat": "^2.6.4",
     "hardhat-deploy": "^0.8.11",
     "hardhat-gas-reporter": "^1.0.4",
-    "prettier": "^2.3.0",
-    "prettier-plugin-solidity": "^1.0.0-beta.11 ",
-    "solhint": "^3.3.6",
+    "prettier": "^2.5.1",
+    "prettier-plugin-sh": "^0.8.1",
+    "prettier-plugin-solidity": "^1.0.0-beta.19",
+    "solhint": "^3.3.7",
     "solhint-config-keep": "github:keep-network/solhint-config-keep",
     "ts-node": "^10.2.1",
     "typechain": "^5.2.0",