@keep-network/tbtc-v2 0.1.1-dev.63 → 0.1.1-dev.66

package/contracts/bridge/DepositSweep.sol

@@ -39,6 +39,29 @@ library DepositSweep {
 
     using BTCUtils for bytes;
 
+    /// @notice Represents temporary information needed during the processing
+    ///         of the deposit sweep Bitcoin transaction inputs. This structure
+    ///         is an internal one and should not be exported outside of the
+    ///         deposit sweep transaction processing code.
+    /// @dev Allows to mitigate "stack too deep" errors on EVM.
+    struct DepositSweepTxInputsProcessingInfo {
+        // Input vector of the deposit sweep Bitcoin transaction. It is
+        // assumed the vector's structure is valid so it must be validated
+        // using e.g. `BTCUtils.validateVin` function before being used
+        // during the processing. The validation is usually done as part
+        // of the `BitcoinTx.validateProof` call that checks the SPV proof.
+        bytes sweepTxInputVector;
+        // Data of the wallet's main UTXO. If no main UTXO exists for the given
+        // sweeping wallet, this parameter's fields should be zeroed to bypass
+        // the main UTXO validation
+        BitcoinTx.UTXO mainUtxo;
+        // Address of the vault where all swept deposits should be routed to.
+        // It is used to validate whether all swept deposits have been revealed
+        // with the same `vault` parameter. It is an optional parameter.
+        // Set to zero address if deposits are not routed to a vault.
+        address vault;
+    }
+
     /// @notice Represents an outcome of the sweep Bitcoin transaction
     ///         inputs processing.
     struct DepositSweepTxInputsInfo {
@@ -83,6 +106,15 @@ library DepositSweep {
     /// @param mainUtxo Data of the wallet's main UTXO, as currently known on
     ///        the Ethereum chain. If no main UTXO exists for the given wallet,
     ///        this parameter is ignored
+    /// @param vault Optional address of the vault where all swept deposits
+    ///        should be routed to. All deposits swept as part of the transaction
+    ///        must have their `vault` parameters set to the same address.
+    ///        If this parameter is set to an address of a trusted vault, swept
+    ///        deposits are routed to that vault.
+    ///        If this parameter is set to the zero address or to an address
+    ///        of a non-trusted vault, swept deposits are not routed to a
+    ///        vault but depositors' balances are increased in the Bank
+    ///        individually.
     /// @dev Requirements:
     ///      - `sweepTx` components must match the expected structure. See
     ///        `BitcoinTx.Info` docs for reference. Their values must exactly
@@ -96,6 +128,9 @@ library DepositSweep {
     ///        revealed deposits UTXOs. That transaction must have only
     ///        one P2(W)PKH output locking funds on the 20-byte wallet public
     ///        key hash.
+    ///      - All revealed deposits that are swept by `sweepTx` must have
+    ///        their `vault` parameters set to the same address as the address
+    ///        passed in the `vault` function parameter.
     ///      - `sweepProof` components must match the expected structure. See
     ///        `BitcoinTx.Proof` docs for reference. The `bitcoinHeaders`
     ///        field must contain a valid number of block headers, not less
@@ -107,7 +142,8 @@ library DepositSweep {
         BridgeState.Storage storage self,
         BitcoinTx.Info calldata sweepTx,
         BitcoinTx.Proof calldata sweepProof,
-        BitcoinTx.UTXO calldata mainUtxo
+        BitcoinTx.UTXO calldata mainUtxo,
+        address vault
     ) external {
         // The actual transaction proof is performed here. After that point, we
         // can assume the transaction happened on Bitcoin chain and has
@@ -132,8 +168,11 @@ library DepositSweep {
         DepositSweepTxInputsInfo
             memory inputsInfo = processDepositSweepTxInputs(
                 self,
-                sweepTx.inputVector,
-                resolvedMainUtxo
+                DepositSweepTxInputsProcessingInfo(
+                    sweepTx.inputVector,
+                    resolvedMainUtxo,
+                    vault
+                )
             );
 
         // Helper variable that will hold the sum of treasury fees paid by
@@ -189,15 +228,26 @@ library DepositSweep {
         // slither-disable-next-line reentrancy-events
         emit DepositsSwept(walletPubKeyHash, sweepTxHash);
 
-        // Update depositors balances in the Bank.
-        self.bank.increaseBalances(
-            inputsInfo.depositors,
-            inputsInfo.depositedAmounts
-        );
+        if (vault != address(0) && self.isVaultTrusted[vault]) {
+            // If the `vault` address is not zero and belongs to a trusted
+            // vault, route the deposits to that vault.
+            self.bank.increaseBalanceAndCall(
+                vault,
+                inputsInfo.depositors,
+                inputsInfo.depositedAmounts
+            );
+        } else {
+            // If the `vault` address is zero or belongs to a non-trusted
+            // vault, increase balances in the Bank individually for each
+            // depositor.
+            self.bank.increaseBalances(
+                inputsInfo.depositors,
+                inputsInfo.depositedAmounts
+            );
+        }
+
         // Pass the treasury fee to the treasury address.
         self.bank.increaseBalance(self.treasury, totalTreasuryFee);
-
-        // TODO: Handle deposits having `vault` set.
     }
 
     /// @notice Resolves sweeping wallet based on the provided wallet public key
@@ -299,32 +349,23 @@ library DepositSweep {
     ///         if one of the inputs cannot be recognized as a pointer to a
     ///         revealed deposit or expected main UTXO.
     ///         This function also marks each processed deposit as swept.
-    /// @param sweepTxInputVector Bitcoin sweep transaction input vector.
-    ///        This function assumes vector's structure is valid so it must be
-    ///        validated using e.g. `BTCUtils.validateVin` function before
-    ///        it is passed here
-    /// @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 info Outcomes of the processing.
+    /// @return resultInfo Outcomes of the processing.
     function processDepositSweepTxInputs(
         BridgeState.Storage storage self,
-        bytes memory sweepTxInputVector,
-        BitcoinTx.UTXO memory mainUtxo
-    ) internal returns (DepositSweepTxInputsInfo memory info) {
+        DepositSweepTxInputsProcessingInfo memory processInfo
+    ) internal returns (DepositSweepTxInputsInfo memory resultInfo) {
         // 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.
-        bool mainUtxoExpected = mainUtxo.txHash != bytes32(0);
+        bool mainUtxoExpected = processInfo.mainUtxo.txHash != bytes32(0);
         bool mainUtxoFound = false;
 
         // 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) = processInfo
+            .sweepTxInputVector
+            .parseVarInt();
 
         // To determine the first input starting index, we must jump over
         // the compactSize uint which prepends the input vector. One byte
@@ -346,11 +387,13 @@ library DepositSweep {
         // 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.
-        info.depositors = new address[](
+        resultInfo.depositors = new address[](
             !mainUtxoExpected ? inputsCount : inputsCount - 1
         );
-        info.depositedAmounts = new uint256[](info.depositors.length);
-        info.treasuryFees = new uint256[](info.depositors.length);
+        resultInfo.depositedAmounts = new uint256[](
+            resultInfo.depositors.length
+        );
+        resultInfo.treasuryFees = new uint256[](resultInfo.depositors.length);
 
         // Initialize helper variables.
         uint256 processedDepositsCount = 0;
@@ -362,7 +405,7 @@ library DepositSweep {
                 uint32 outpointIndex,
                 uint256 inputLength
             ) = parseDepositSweepTxInputAt(
-                    sweepTxInputVector,
+                    processInfo.sweepTxInputVector,
                     inputStartingIndex
                 );
 
@@ -377,7 +420,12 @@ library DepositSweep {
                 // a revealed deposit.
                 require(deposit.sweptAt == 0, "Deposit already swept");
 
-                if (processedDepositsCount == info.depositors.length) {
+                require(
+                    deposit.vault == processInfo.vault,
+                    "Deposit should be routed to another vault"
+                );
+
+                if (processedDepositsCount == resultInfo.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
@@ -390,22 +438,27 @@ library DepositSweep {
                 /* solhint-disable-next-line not-rely-on-time */
                 deposit.sweptAt = uint32(block.timestamp);
 
-                info.depositors[processedDepositsCount] = deposit.depositor;
-                info.depositedAmounts[processedDepositsCount] = deposit.amount;
-                info.inputsTotalValue += info.depositedAmounts[
+                resultInfo.depositors[processedDepositsCount] = deposit
+                    .depositor;
+                resultInfo.depositedAmounts[processedDepositsCount] = deposit
+                    .amount;
+                resultInfo.inputsTotalValue += resultInfo.depositedAmounts[
                     processedDepositsCount
                 ];
-                info.treasuryFees[processedDepositsCount] = deposit.treasuryFee;
+                resultInfo.treasuryFees[processedDepositsCount] = deposit
+                    .treasuryFee;
 
                 processedDepositsCount++;
             } else if (
                 mainUtxoExpected != mainUtxoFound &&
-                mainUtxo.txHash == outpointTxHash &&
-                mainUtxo.txOutputIndex == outpointIndex
+                processInfo.mainUtxo.txHash == outpointTxHash &&
+                processInfo.mainUtxo.txOutputIndex == outpointIndex
             ) {
                 // If we entered here, that means the input was identified as
                 // the expected main UTXO.
-                info.inputsTotalValue += mainUtxo.txOutputValue;
+                resultInfo.inputsTotalValue += processInfo
+                    .mainUtxo
+                    .txOutputValue;
                 mainUtxoFound = true;
 
                 // Main UTXO used as an input, mark it as spent.
@@ -426,7 +479,7 @@ library DepositSweep {
         }
 
         // Construction of the input processing loop guarantees that:
-        // `processedDepositsCount == info.depositors.length == info.depositedAmounts.length`
+        // `processedDepositsCount == resultInfo.depositors.length == resultInfo.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(
@@ -441,7 +494,7 @@ library DepositSweep {
             "Expected main UTXO not present in sweep transaction inputs"
         );
 
-        return info;
+        return resultInfo;
     }
 
     /// @notice Parses a Bitcoin transaction input starting at the given index.

package/contracts/bridge/MovingFunds.sol

@@ -93,6 +93,8 @@ library MovingFunds {
         address submitter
     );
 
+    event MovingFundsTimeoutReset(bytes20 walletPubKeyHash);
+
     event MovingFundsCompleted(
         bytes20 walletPubKeyHash,
         bytes32 movingFundsTxHash
@@ -206,10 +208,8 @@ library MovingFunds {
 
         // This requirement fails only when `liveWalletsCount` is zero. In
         // that case, the system cannot accept the commitment and must provide
-        // new wallets first.
-        //
-        // TODO: Expose separate function to reset the moving funds timeout
-        //       if no Live wallets exist in the system.
+        // new wallets first. However, the wallet supposed to submit the
+        // commitment can keep resetting the moving funds timeout until then.
         require(expectedTargetWalletsCount > 0, "No target wallets available");
 
         require(
@@ -252,6 +252,44 @@ library MovingFunds {
         );
     }
 
+    /// @notice Resets the moving funds timeout for the given wallet if the
+    ///         target wallet commitment cannot be submitted due to a lack
+    ///         of live wallets in the system.
+    /// @param walletPubKeyHash 20-byte public key hash of the moving funds wallet
+    /// @dev Requirements:
+    ///      - The wallet must be in the MovingFunds state
+    ///      - The target wallets commitment must not be already submitted for
+    ///        the given moving funds wallet
+    ///      - Live wallets count must be zero
+    function resetMovingFundsTimeout(
+        BridgeState.Storage storage self,
+        bytes20 walletPubKeyHash
+    ) external {
+        Wallets.Wallet storage wallet = self.registeredWallets[
+            walletPubKeyHash
+        ];
+
+        require(
+            wallet.state == Wallets.WalletState.MovingFunds,
+            "ECDSA wallet must be in MovingFunds state"
+        );
+
+        // If the moving funds wallet already submitted their target wallets
+        // commitment, there is no point to reset the timeout since the
+        // wallet can make the BTC transaction and submit the proof.
+        require(
+            wallet.movingFundsTargetWalletsCommitmentHash == bytes32(0),
+            "Target wallets commitment already submitted"
+        );
+
+        require(self.liveWalletsCount == 0, "Live wallets count must be zero");
+
+        /* solhint-disable-next-line not-rely-on-time */
+        wallet.movingFundsRequestedAt = uint32(block.timestamp);
+
+        emit MovingFundsTimeoutReset(walletPubKeyHash);
+    }
+
     /// @notice Used by the wallet to prove the BTC moving funds transaction
     ///         and to make the necessary state changes. Moving funds is only
     ///         accepted if it satisfies SPV proof.

package/contracts/bridge/Redemption.sol

@@ -825,7 +825,6 @@ library Redemption {
             request.treasuryFee;
 
         require(
-            // TODO: Allow the wallets in `Closing` state when the state is added
             wallet.state == Wallets.WalletState.Live ||
                 wallet.state == Wallets.WalletState.MovingFunds ||
                 wallet.state == Wallets.WalletState.Terminated,

package/export.json

@@ -14031,6 +14031,19 @@
           ],
           "name": "MovingFundsTimedOut",
           "type": "event"
+        },
+        {
+          "anonymous": false,
+          "inputs": [
+            {
+              "indexed": false,
+              "internalType": "bytes20",
+              "name": "walletPubKeyHash",
+              "type": "bytes20"
+            }
+          ],
+          "name": "MovingFundsTimeoutReset",
+          "type": "event"
         }
       ]
     },
@@ -14473,6 +14486,19 @@
           "name": "MovingFundsTimedOut",
           "type": "event"
         },
+        {
+          "anonymous": false,
+          "inputs": [
+            {
+              "indexed": false,
+              "internalType": "bytes20",
+              "name": "walletPubKeyHash",
+              "type": "bytes20"
+            }
+          ],
+          "name": "MovingFundsTimeoutReset",
+          "type": "event"
+        },
         {
           "anonymous": false,
           "inputs": [
@@ -15535,6 +15561,19 @@
           "stateMutability": "nonpayable",
           "type": "function"
         },
+        {
+          "inputs": [
+            {
+              "internalType": "bytes20",
+              "name": "walletPubKeyHash",
+              "type": "bytes20"
+            }
+          ],
+          "name": "resetMovingFundsTimeout",
+          "outputs": [],
+          "stateMutability": "nonpayable",
+          "type": "function"
+        },
         {
           "inputs": [
             {
@@ -16037,6 +16076,11 @@
               "internalType": "struct BitcoinTx.UTXO",
               "name": "mainUtxo",
               "type": "tuple"
+            },
+            {
+              "internalType": "address",
+              "name": "vault",
+              "type": "address"
             }
           ],
           "name": "submitDepositSweepProof",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keep-network/tbtc-v2",
-  "version": "0.1.1-dev.63+main.68e692f8fe53043af3c81bd88afd16954759ad5d",
+  "version": "0.1.1-dev.66+main.194aaf49b16b3d5ef27df189fbc4a71cf3b779d0",
   "license": "MIT",
   "files": [
     "artifacts/",