@keep-network/tbtc-v2 0.1.1-dev.16 → 0.1.1-dev.19

package/contracts/bridge/Bridge.sol

@@ -101,12 +101,40 @@ contract Bridge is Ownable {
         // Address of the Bank vault the deposit is routed to.
         // Optional, can be 0x0.
         address vault;
+        // Treasury TBTC fee in satoshi at the moment of deposit reveal.
+        uint64 treasuryFee;
         // UNIX timestamp the deposit was swept at. Note this is not the
         // time when the deposit was swept on the Bitcoin chain but actually
         // the time when the sweep proof was delivered to the Ethereum chain.
         uint32 sweptAt;
     }
 
+    /// @notice Represents an outcome of the sweep Bitcoin transaction
+    ///         inputs processing.
+    struct SweepTxInputsInfo {
+        // Sum of all inputs values i.e. all deposits and main UTXO value,
+        // if present.
+        uint256 inputsTotalValue;
+        // Addresses of depositors who performed processed deposits. Ordered in
+        // the same order as deposits inputs in the input vector. Size of this
+        // array is either equal to the number of inputs (main UTXO doesn't
+        // exist) or less by one (main UTXO exists and is pointed by one of
+        // the inputs).
+        address[] depositors;
+        // Amounts of deposits corresponding to processed deposits. Ordered in
+        // the same order as deposits inputs in the input vector. Size of this
+        // array is either equal to the number of inputs (main UTXO doesn't
+        // exist) or less by one (main UTXO exists and is pointed by one of
+        // the inputs).
+        uint256[] depositedAmounts;
+        // Values of the treasury fee corresponding to processed deposits.
+        // Ordered in the same order as deposits inputs in the input vector.
+        // Size of this array is either equal to the number of inputs (main
+        // UTXO doesn't exist) or less by one (main UTXO exists and is pointed
+        // by one of the inputs).
+        uint256[] treasuryFees;
+    }
+
     /// @notice Represents a redemption request.
     struct RedemptionRequest {
         // ETH address of the redeemer who created the request.
@@ -187,17 +215,33 @@ contract Bridge is Ownable {
     ///         Treasury takes part in the operators rewarding process.
     address public immutable treasury;
 
+    /// TODO: Make it governable.
+    /// @notice Divisor used to compute the treasury fee taken from each
+    ///         deposit and transferred to the treasury upon sweep proof
+    ///         submission. That fee is computed as follows:
+    ///         `treasuryFee = depositedAmount / depositTreasuryFeeDivisor`
+    ///         For example, if the treasury fee needs to be 2% of each deposit,
+    ///         the `redemptionTreasuryFeeDivisor` should be set to `50`
+    ///         because `1/50 = 0.02 = 2%`.
+    uint64 public depositTreasuryFeeDivisor;
+
     /// 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
@@ -333,8 +377,9 @@ contract Bridge is Ownable {
         txProofDifficultyFactor = _txProofDifficultyFactor;
 
         // TODO: Revisit initial values.
+        depositTreasuryFeeDivisor = 2000; // 1/2000 == 5bps == 0.05% == 0.0005
         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
     }
@@ -490,6 +535,9 @@ contract Bridge is Ownable {
         /* solhint-disable-next-line not-rely-on-time */
         deposit.revealedAt = uint32(block.timestamp);
         deposit.vault = reveal.vault;
+        deposit.treasuryFee = depositTreasuryFeeDivisor > 0
+            ? fundingOutputAmount / depositTreasuryFeeDivisor
+            : 0;
 
         emit DepositRevealed(
             fundingTxHash,
@@ -586,30 +634,39 @@ contract Bridge is Ownable {
             resolvedMainUtxo = mainUtxo;
         }
 
-        // Process sweep transaction inputs and extract their value sum and
-        // all information needed to perform deposit bookkeeping.
-        (
-            uint256 sweepTxInputsValue,
-            address[] memory depositors,
-            uint256[] memory depositedAmounts
-        ) = processSweepTxInputs(sweepTx.inputVector, resolvedMainUtxo);
-
-        // Compute the sweep transaction fee which is a difference between
-        // inputs amounts sum and the output amount.
-        // TODO: Check fee against max fee.
-        uint256 fee = sweepTxInputsValue - sweepTxOutputValue;
-        // Calculate fee share by dividing the total fee by deposits count.
+        // Process sweep transaction inputs and extract all information needed
+        // to perform deposit bookkeeping.
+        SweepTxInputsInfo memory inputsInfo = processSweepTxInputs(
+            sweepTx.inputVector,
+            resolvedMainUtxo
+        );
+
+        // Helper variable that will hold the sum of treasury fees paid by
+        // all deposits.
+        uint256 totalTreasuryFee = 0;
+
+        // Calculate the transaction fee per deposit by dividing the total
+        // transaction fee by deposits count. The total fee is just the
+        // difference between inputs amounts sum and the output amount.
         // TODO: Deal with precision loss by having the last depositor pay
-        //       the higher fee than others if there is a change, just like it has
-        //       been proposed for the redemption flow. See:
+        //       the higher transaction fee than others if there is a change,
+        //       just like it has been proposed in discussion:
         //       https://github.com/keep-network/tbtc-v2/pull/128#discussion_r800555359.
-        uint256 feeShare = fee / depositedAmounts.length;
-        // Reduce each deposit amount by fee share value.
-        for (uint256 i = 0; i < depositedAmounts.length; i++) {
-            // We don't have to check if `feeShare` is bigger than the amount
-            // since we have the dust threshold preventing against too small
-            // deposits amounts.
-            depositedAmounts[i] -= feeShare;
+        // TODO: Check txFee against max fee.
+        uint256 txFee = (inputsInfo.inputsTotalValue - sweepTxOutputValue) /
+            inputsInfo.depositedAmounts.length;
+
+        // Reduce each deposit amount by treasury fee and transaction fee.
+        for (uint256 i = 0; i < inputsInfo.depositedAmounts.length; i++) {
+            // There is no need to check whether
+            // `inputsInfo.depositedAmounts[i] - inputsInfo.treasuryFees[i] - txFee > 0`
+            // since the `depositDustThreshold` should force that condition
+            // to be always true.
+            inputsInfo.depositedAmounts[i] =
+                inputsInfo.depositedAmounts[i] -
+                inputsInfo.treasuryFees[i] -
+                txFee;
+            totalTreasuryFee += inputsInfo.treasuryFees[i];
         }
 
         // Record this sweep data and assign them to the wallet public key hash
@@ -622,7 +679,12 @@ contract Bridge is Ownable {
         emit DepositsSwept(walletPubKeyHash, sweepTxHash);
 
         // Update depositors balances in the Bank.
-        bank.increaseBalances(depositors, depositedAmounts);
+        bank.increaseBalances(
+            inputsInfo.depositors,
+            inputsInfo.depositedAmounts
+        );
+        // Pass the treasury fee to the treasury address.
+        bank.increaseBalance(treasury, totalTreasuryFee);
 
         // TODO: Handle deposits having `vault` set.
     }
@@ -783,29 +845,11 @@ contract Bridge is Ownable {
     /// @param mainUtxo Data of the wallet's main UTXO. If no main UTXO
     ///        exists for the given the wallet, this parameter's fields should
     ///        be zeroed to bypass the main UTXO validation
-    /// @return inputsTotalValue Sum of all inputs values i.e. all deposits and
-    ///         main UTXO value, if present.
-    /// @return depositors Addresses of depositors who performed processed
-    ///         deposits. Ordered in the same order as deposits inputs in the
-    ///         input vector. Size of this array is either equal to the
-    ///         number of inputs (main UTXO doesn't exist) or less by one
-    ///         (main UTXO exists and is pointed by one of the inputs).
-    /// @return depositedAmounts Amounts of deposits corresponding to processed
-    ///         deposits. Ordered in the same order as deposits inputs in the
-    ///         input vector. Size of this array is either equal to the
-    ///         number of inputs (main UTXO doesn't exist) or less by one
-    ///         (main UTXO exists and is pointed by one of the inputs).
+    /// @return info Outcomes of the processing.
     function processSweepTxInputs(
         bytes memory sweepTxInputVector,
         BitcoinTx.UTXO memory mainUtxo
-    )
-        internal
-        returns (
-            uint256 inputsTotalValue,
-            address[] memory depositors,
-            uint256[] memory depositedAmounts
-        )
-    {
+    ) internal returns (SweepTxInputsInfo memory info) {
         // If the passed `mainUtxo` parameter's values are zeroed, the main UTXO
         // for the given wallet doesn't exist and it is not expected to be
         // included in the sweep transaction input vector.
@@ -840,10 +884,11 @@ contract Bridge is Ownable {
         // Determine the swept deposits count. If main UTXO is NOT expected,
         // all inputs should be deposits. If main UTXO is expected, one input
         // should point to that main UTXO.
-        depositors = new address[](
+        info.depositors = new address[](
             !mainUtxoExpected ? inputsCount : inputsCount - 1
         );
-        depositedAmounts = new uint256[](depositors.length);
+        info.depositedAmounts = new uint256[](info.depositors.length);
+        info.treasuryFees = new uint256[](info.depositors.length);
 
         // Initialize helper variables.
         uint256 processedDepositsCount = 0;
@@ -867,7 +912,7 @@ contract Bridge is Ownable {
                 // a revealed deposit.
                 require(deposit.sweptAt == 0, "Deposit already swept");
 
-                if (processedDepositsCount == depositors.length) {
+                if (processedDepositsCount == info.depositors.length) {
                     // If this condition is true, that means a deposit input
                     // took place of an expected main UTXO input.
                     // In other words, there is no expected main UTXO
@@ -880,9 +925,12 @@ contract Bridge is Ownable {
                 /* solhint-disable-next-line not-rely-on-time */
                 deposit.sweptAt = uint32(block.timestamp);
 
-                depositors[processedDepositsCount] = deposit.depositor;
-                depositedAmounts[processedDepositsCount] = deposit.amount;
-                inputsTotalValue += depositedAmounts[processedDepositsCount];
+                info.depositors[processedDepositsCount] = deposit.depositor;
+                info.depositedAmounts[processedDepositsCount] = deposit.amount;
+                info.inputsTotalValue += info.depositedAmounts[
+                    processedDepositsCount
+                ];
+                info.treasuryFees[processedDepositsCount] = deposit.treasuryFee;
 
                 processedDepositsCount++;
             } else if (
@@ -891,7 +939,7 @@ contract Bridge is Ownable {
             ) {
                 // If we entered here, that means the input was identified as
                 // the expected main UTXO.
-                inputsTotalValue += mainUtxo.txOutputValue;
+                info.inputsTotalValue += mainUtxo.txOutputValue;
                 mainUtxoFound = true;
             } else {
                 revert("Unknown input type");
@@ -903,7 +951,7 @@ contract Bridge is Ownable {
         }
 
         // Construction of the input processing loop guarantees that:
-        // `processedDepositsCount == depositors.length == depositedAmounts.length`
+        // `processedDepositsCount == info.depositors.length == info.depositedAmounts.length`
         // is always true at this point. We just use the first variable
         // to assert the total count of swept deposit is bigger than zero.
         require(
@@ -918,7 +966,7 @@ contract Bridge is Ownable {
             "Expected main UTXO not present in sweep transaction inputs"
         );
 
-        return (inputsTotalValue, depositors, depositedAmounts);
+        return info;
     }
 
     /// @notice Parses a Bitcoin transaction input starting at the given index.
@@ -970,7 +1018,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
@@ -1065,7 +1113,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keep-network/tbtc-v2",
-  "version": "0.1.1-dev.16+main.d05213ad4dbd8982d3731c67f312ed445462aa4d",
+  "version": "0.1.1-dev.19+main.6afd5b941bb544214e7e77a28f5688e0df8b05ad",
   "license": "MIT",
   "files": [
     "artifacts/",