@keep-network/tbtc-v2 0.1.1-dev.54 → 0.1.1-dev.57

package/contracts/bridge/MovingFunds.sol

@@ -31,6 +31,9 @@ import "./Wallets.sol";
 ///      funds to other wallets in the Bridge. The wallet needs to commit to
 ///      which other Live wallets it is moving the funds to and then, provide an
 ///      SPV proof of moving funds to the previously committed wallets.
+///      Once the proof is submitted, all target wallets are supposed to
+///      sweep the received UTXOs with their own main UTXOs in order to
+///      update their BTC balances.
 library MovingFunds {
     using BridgeState for BridgeState.Storage;
     using Wallets for BridgeState.Storage;
@@ -39,6 +42,38 @@ library MovingFunds {
     using BTCUtils for bytes;
     using BytesLib for bytes;
 
+    /// @notice Represents temporary information needed during the processing
+    ///         of the moving funds Bitcoin transaction outputs. This structure
+    ///         is an internal one and should not be exported outside of the
+    ///         moving funds transaction processing code.
+    /// @dev Allows to mitigate "stack too deep" errors on EVM.
+    struct MovingFundsTxOutputsProcessingInfo {
+        // 32-byte hash of the moving funds Bitcoin transaction.
+        bytes32 movingFundsTxHash;
+        // Output vector of the moving funds Bitcoin transaction. It is
+        // assumed the vector's structure is valid so it must be validated
+        // using e.g. `BTCUtils.validateVout` 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 movingFundsTxOutputVector;
+    }
+
+    /// @notice Represents a moved funds sweep request. The request is
+    ///         registered in `submitMovingFundsProof` where we know funds
+    ///         have been moved to the target wallet and the only step left is
+    ///         to have the target wallet sweep them.
+    struct MovedFundsSweepRequest {
+        // 20-byte public key hash of the wallet supposed to sweep the UTXO
+        // representing the received funds with their own main UTXO
+        bytes20 walletPubKeyHash;
+        // Value of the received funds.
+        uint64 value;
+        // UNIX timestamp the request was created at.
+        uint32 createdAt;
+        // UNIX timestamp the funds were swept at.
+        uint32 sweptAt;
+    }
+
     event MovingFundsCommitmentSubmitted(
         bytes20 walletPubKeyHash,
         bytes20[] targetWallets,
@@ -54,6 +89,8 @@ library MovingFunds {
 
     event MovingFundsBelowDustReported(bytes20 walletPubKeyHash);
 
+    event MovedFundsSwept(bytes20 walletPubKeyHash, bytes32 sweepTxHash);
+
     /// @notice Submits the moving funds target wallets commitment.
     ///         Once all requirements are met, that function registers the
     ///         target wallets commitment and opens the way for moving funds
@@ -70,6 +107,7 @@ library MovingFunds {
     /// @dev Requirements:
     ///      - The source wallet must be in the MovingFunds state
     ///      - The source wallet must not have pending redemption requests
+    ///      - The source wallet must not have pending moved funds sweep requests
     ///      - The source wallet must not have submitted its commitment already
     ///      - The expression `keccak256(abi.encode(walletMembersIDs))` must
     ///        be exactly the same as the hash stored under `membersIdsHash`
@@ -115,6 +153,11 @@ library MovingFunds {
             "Source wallet must handle all pending redemptions first"
         );
 
+        require(
+            wallet.pendingMovedFundsSweepRequestsCount == 0,
+            "Source wallet must handle all pending moved funds sweep requests first"
+        );
+
         require(
             wallet.movingFundsTargetWalletsCommitmentHash == bytes32(0),
             "Target wallets commitment already submitted"
@@ -263,7 +306,13 @@ library MovingFunds {
         (
             bytes32 targetWalletsHash,
             uint256 outputsTotalValue
-        ) = processMovingFundsTxOutputs(movingFundsTx.outputVector);
+        ) = processMovingFundsTxOutputs(
+                self,
+                MovingFundsTxOutputsProcessingInfo(
+                    movingFundsTxHash,
+                    movingFundsTx.outputVector
+                )
+            );
 
         require(
             mainUtxo.txOutputValue - outputsTotalValue <=
@@ -278,10 +327,8 @@ library MovingFunds {
 
     /// @notice Processes the moving funds Bitcoin transaction output vector
     ///         and extracts information required for further processing.
-    /// @param movingFundsTxOutputVector Bitcoin moving funds transaction output
-    ///        vector. This function assumes vector's structure is valid so it
-    ///        must be validated using e.g. `BTCUtils.validateVout` function
-    ///        before it is passed here
+    /// @param processInfo Processing info containing the moving funds tx
+    ///        hash and output vector.
     /// @return targetWalletsHash keccak256 hash over the list of actual
     ///         target wallets used in the transaction.
     /// @return outputsTotalValue Sum of all outputs values.
@@ -290,18 +337,17 @@ library MovingFunds {
     ///        be validated by the caller as stated in their parameter doc.
     ///      - Each output must refer to a 20-byte public key hash.
     ///      - The total outputs value must be evenly divided over all outputs.
-    function processMovingFundsTxOutputs(bytes memory movingFundsTxOutputVector)
-        internal
-        pure
-        returns (bytes32 targetWalletsHash, uint256 outputsTotalValue)
-    {
+    function processMovingFundsTxOutputs(
+        BridgeState.Storage storage self,
+        MovingFundsTxOutputsProcessingInfo memory processInfo
+    ) internal returns (bytes32 targetWalletsHash, uint256 outputsTotalValue) {
         // Determining the total number of Bitcoin transaction outputs in
         // the same way as for number of inputs. See `BitcoinTx.outputVector`
         // docs for more details.
         (
             uint256 outputsCompactSizeUintLength,
             uint256 outputsCount
-        ) = movingFundsTxOutputVector.parseVarInt();
+        ) = processInfo.movingFundsTxOutputVector.parseVarInt();
 
         // To determine the first output starting index, we must jump over
         // the compactSize uint which prepends the output vector. One byte
@@ -323,85 +369,64 @@ library MovingFunds {
         bytes20[] memory targetWallets = new bytes20[](outputsCount);
         uint64[] memory outputsValues = new uint64[](outputsCount);
 
-        // Outputs processing loop.
-        for (uint256 i = 0; i < outputsCount; i++) {
-            uint256 outputLength = movingFundsTxOutputVector
+        // Outputs processing loop. Note that the `outputIndex` must be
+        // `uint32` to build proper `movedFundsSweepRequests` keys.
+        for (
+            uint32 outputIndex = 0;
+            outputIndex < outputsCount;
+            outputIndex++
+        ) {
+            uint256 outputLength = processInfo
+                .movingFundsTxOutputVector
                 .determineOutputLengthAt(outputStartingIndex);
 
-            bytes memory output = movingFundsTxOutputVector.slice(
+            bytes memory output = processInfo.movingFundsTxOutputVector.slice(
                 outputStartingIndex,
                 outputLength
             );
 
-            // Extract the output script payload.
-            bytes memory targetWalletPubKeyHashBytes = output.extractHash();
-            // Output script payload must refer to a known wallet public key
-            // hash which is always 20-byte.
-            require(
-                targetWalletPubKeyHashBytes.length == 20,
-                "Target wallet public key hash must have 20 bytes"
-            );
-
-            bytes20 targetWalletPubKeyHash = targetWalletPubKeyHashBytes
-                .slice20(0);
-
-            // The next step is making sure that the 20-byte public key hash
-            // is actually used in the right context of a P2PKH or P2WPKH
-            // output. To do so, we must extract the full script from the output
-            // and compare with the expected P2PKH and P2WPKH scripts
-            // referring to that 20-byte public key hash. The output consists
-            // of an 8-byte value and a variable length script. To extract the
-            // script we slice the output starting from 9th byte until the end.
-            bytes32 outputScriptKeccak = keccak256(
-                output.slice(8, output.length - 8)
-            );
-            // Build the expected P2PKH script which has the following byte
-            // format: <0x1976a914> <20-byte PKH> <0x88ac>. According to
-            // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:
-            // - 0x19: Byte length of the entire script
-            // - 0x76: OP_DUP
-            // - 0xa9: OP_HASH160
-            // - 0x14: Byte length of the public key hash
-            // - 0x88: OP_EQUALVERIFY
-            // - 0xac: OP_CHECKSIG
-            // which matches the P2PKH structure as per:
-            // https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash
-            bytes32 targetWalletP2PKHScriptKeccak = keccak256(
-                abi.encodePacked(
-                    hex"1976a914",
-                    targetWalletPubKeyHash,
-                    hex"88ac"
-                )
-            );
-            // Build the expected P2WPKH script which has the following format:
-            // <0x160014> <20-byte PKH>. According to
-            // https://en.bitcoin.it/wiki/Script#Opcodes this translates to:
-            // - 0x16: Byte length of the entire script
-            // - 0x00: OP_0
-            // - 0x14: Byte length of the public key hash
-            // which matches the P2WPKH structure as per:
-            // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#P2WPKH
-            bytes32 targetWalletP2WPKHScriptKeccak = keccak256(
-                abi.encodePacked(hex"160014", targetWalletPubKeyHash)
-            );
-            // Make sure the actual output script matches either the P2PKH
-            // or P2WPKH format.
-            require(
-                outputScriptKeccak == targetWalletP2PKHScriptKeccak ||
-                    outputScriptKeccak == targetWalletP2WPKHScriptKeccak,
-                "Output must be P2PKH or P2WPKH"
-            );
+            bytes20 targetWalletPubKeyHash = self.extractPubKeyHash(output);
 
             // Add the wallet public key hash to the list that will be used
             // to build the result list hash. There is no need to check if
             // given output is a change here because the actual target wallet
             // list must be exactly the same as the pre-committed target wallet
             // list which is guaranteed to be valid.
-            targetWallets[i] = targetWalletPubKeyHash;
+            targetWallets[outputIndex] = targetWalletPubKeyHash;
 
             // Extract the value from given output.
-            outputsValues[i] = output.extractValue();
-            outputsTotalValue += outputsValues[i];
+            outputsValues[outputIndex] = output.extractValue();
+            outputsTotalValue += outputsValues[outputIndex];
+
+            // Register a moved funds sweep request that must be handled
+            // by the target wallet. The target wallet must sweep the
+            // received funds with their own main UTXO in order to update
+            // their BTC balance. Worth noting there is no need to check
+            // if the sweep request already exists in the system because
+            // the moving funds wallet is moved to the Closing state after
+            // submitting the moving funds proof so there is no possibility
+            // to submit the proof again and register the sweep request twice.
+            self.movedFundsSweepRequests[
+                uint256(
+                    keccak256(
+                        abi.encodePacked(
+                            processInfo.movingFundsTxHash,
+                            outputIndex
+                        )
+                    )
+                )
+            ] = MovedFundsSweepRequest(
+                targetWalletPubKeyHash,
+                outputsValues[outputIndex],
+                /* solhint-disable-next-line not-rely-on-time */
+                uint32(block.timestamp),
+                0
+            );
+            // We added a new moved funds sweep request for the target wallet
+            // so we must increment their request counter.
+            self
+                .registeredWallets[targetWalletPubKeyHash]
+                .pendingMovedFundsSweepRequestsCount++;
 
             // Make the `outputStartingIndex` pointing to the next output by
             // increasing it by current output's length.
@@ -521,4 +546,383 @@ library MovingFunds {
         // slither-disable-next-line reentrancy-events
         emit MovingFundsBelowDustReported(walletPubKeyHash);
     }
+
+    /// @notice Used by the wallet to prove the BTC moved funds sweep
+    ///         transaction and to make the necessary state changes. Moved
+    ///         funds sweep is only accepted if it satisfies SPV proof.
+    ///
+    ///         The function validates the sweep transaction structure by
+    ///         checking if it actually spends the moved funds UTXO and the
+    ///         sweeping wallet's main UTXO (optionally), and if it locks the
+    ///         value on the sweeping wallet's 20-byte public key hash using a
+    ///         reasonable transaction fee. If all preconditions are
+    ///         met, this function updates the sweeping wallet main UTXO, thus
+    ///         their BTC balance.
+    ///
+    ///         It is possible to prove the given sweep transaction only
+    ///         one time.
+    /// @param sweepTx Bitcoin sweep funds transaction data
+    /// @param sweepProof Bitcoin sweep funds proof data
+    /// @param mainUtxo Data of the sweeping wallet's main UTXO, as currently
+    ///        known on the Ethereum chain
+    /// @dev Requirements:
+    ///      - `sweepTx` components must match the expected structure. See
+    ///        `BitcoinTx.Info` docs for reference. Their values must exactly
+    ///        correspond to appropriate Bitcoin transaction fields to produce
+    ///        a provable transaction hash.
+    ///      - The `sweepTx` should represent a Bitcoin transaction with
+    ///        the first input pointing to a wallet's sweep request and,
+    ///        optionally, the second input pointing to the wallet's main UTXO,
+    ///        if the sweeping wallet has a main UTXO set. There should be only
+    ///        one output locking funds on the sweeping wallet 20-byte public
+    ///        key hash.
+    ///      - `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
+    ///        than the `txProofDifficultyFactor` contract constant.
+    ///      - `mainUtxo` components must point to the recent main UTXO
+    ///        of the sweeping wallet, as currently known on the Ethereum chain.
+    ///        If there is no main UTXO, this parameter is ignored.
+    ///      - The sweeping wallet must be in the Live or MovingFunds state.
+    ///      - The total Bitcoin transaction fee must be lesser or equal
+    ///        to `movedFundsSweepTxMaxTotalFee` governable parameter.
+    function submitMovedFundsSweepProof(
+        BridgeState.Storage storage self,
+        BitcoinTx.Info calldata sweepTx,
+        BitcoinTx.Proof calldata sweepProof,
+        BitcoinTx.UTXO calldata mainUtxo
+    ) external {
+        // The actual transaction proof is performed here. After that point, we
+        // can assume the transaction happened on Bitcoin chain and has
+        // a sufficient number of confirmations as determined by
+        // `txProofDifficultyFactor` constant.
+        bytes32 sweepTxHash = self.validateProof(sweepTx, sweepProof);
+
+        (
+            bytes20 walletPubKeyHash,
+            uint64 sweepTxOutputValue
+        ) = processMovedFundsSweepTxOutput(self, sweepTx.outputVector);
+
+        (
+            Wallets.Wallet storage wallet,
+            BitcoinTx.UTXO memory resolvedMainUtxo
+        ) = resolveMovedFundsSweepingWallet(self, walletPubKeyHash, mainUtxo);
+
+        uint256 sweepTxInputsTotalValue = processMovedFundsSweepTxInputs(
+            self,
+            sweepTx.inputVector,
+            resolvedMainUtxo,
+            walletPubKeyHash
+        );
+
+        require(
+            sweepTxInputsTotalValue - sweepTxOutputValue <=
+                self.movedFundsSweepTxMaxTotalFee,
+            "Transaction fee is too high"
+        );
+
+        // Use the sweep transaction output as the new sweeping wallet's main UTXO.
+        // Transaction output index is always 0 as sweep transaction always
+        // contains only one output.
+        wallet.mainUtxoHash = keccak256(
+            abi.encodePacked(sweepTxHash, uint32(0), sweepTxOutputValue)
+        );
+
+        // slither-disable-next-line reentrancy-events
+        emit MovedFundsSwept(walletPubKeyHash, sweepTxHash);
+    }
+
+    /// @notice Processes the Bitcoin moved funds sweep transaction output vector
+    ///         by extracting the single output and using it to gain additional
+    ///         information required for further processing (e.g. value and
+    ///         wallet public key hash).
+    /// @param sweepTxOutputVector Bitcoin moved funds sweep transaction output
+    ///        vector.
+    ///        This function assumes vector's structure is valid so it must be
+    ///        validated using e.g. `BTCUtils.validateVout` function before
+    ///        it is passed here
+    /// @return walletPubKeyHash 20-byte wallet public key hash.
+    /// @return value 8-byte moved funds sweep transaction output value.
+    /// @dev Requirements:
+    ///      - Output vector must contain only one output
+    ///      - The single output must be of P2PKH or P2WPKH type and lock the
+    ///        funds on a 20-byte public key hash
+    function processMovedFundsSweepTxOutput(
+        BridgeState.Storage storage self,
+        bytes memory sweepTxOutputVector
+    ) internal view returns (bytes20 walletPubKeyHash, uint64 value) {
+        // To determine the total number of sweep transaction outputs, we need to
+        // parse the compactSize uint (VarInt) the output vector is prepended by.
+        // That compactSize uint encodes the number of vector elements using the
+        // format presented in:
+        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers
+        // We don't need asserting the compactSize uint is parseable since it
+        // was already checked during `validateVout` validation performed as
+        // part of the `BitcoinTx.validateProof` call.
+        // See `BitcoinTx.outputVector` docs for more details.
+        (, uint256 outputsCount) = sweepTxOutputVector.parseVarInt();
+        require(
+            outputsCount == 1,
+            "Moved funds sweep transaction must have a single output"
+        );
+
+        bytes memory output = sweepTxOutputVector.extractOutputAtIndex(0);
+        walletPubKeyHash = self.extractPubKeyHash(output);
+        value = output.extractValue();
+
+        return (walletPubKeyHash, value);
+    }
+
+    /// @notice Resolves sweeping wallet based on the provided wallet public key
+    ///         hash. Validates the wallet state and current main UTXO, as
+    ///         currently known on the Ethereum chain.
+    /// @param walletPubKeyHash public key hash of the wallet proving the sweep
+    ///        Bitcoin transaction.
+    /// @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
+    /// @return wallet Data of the sweeping wallet.
+    /// @return resolvedMainUtxo The actual main UTXO of the sweeping wallet
+    ///         resolved by cross-checking the `mainUtxo` parameter with
+    ///         the chain state. If the validation went well, this is the
+    ///         plain-text main UTXO corresponding to the `wallet.mainUtxoHash`.
+    /// @dev Requirements:
+    ///     - Sweeping wallet must be either in Live or MovingFunds state.
+    ///     - If the main UTXO of the sweeping wallet exists in the storage,
+    ///       the passed `mainUTXO` parameter must be equal to the stored one.
+    function resolveMovedFundsSweepingWallet(
+        BridgeState.Storage storage self,
+        bytes20 walletPubKeyHash,
+        BitcoinTx.UTXO calldata mainUtxo
+    )
+        internal
+        view
+        returns (
+            Wallets.Wallet storage wallet,
+            BitcoinTx.UTXO memory resolvedMainUtxo
+        )
+    {
+        wallet = self.registeredWallets[walletPubKeyHash];
+
+        Wallets.WalletState walletState = wallet.state;
+        require(
+            walletState == Wallets.WalletState.Live ||
+                walletState == Wallets.WalletState.MovingFunds,
+            "Wallet must be in Live or MovingFunds state"
+        );
+
+        // 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.
+        resolvedMainUtxo = BitcoinTx.UTXO(bytes32(0), 0, 0);
+        bytes32 mainUtxoHash = wallet.mainUtxoHash;
+        if (mainUtxoHash != bytes32(0)) {
+            require(
+                keccak256(
+                    abi.encodePacked(
+                        mainUtxo.txHash,
+                        mainUtxo.txOutputIndex,
+                        mainUtxo.txOutputValue
+                    )
+                ) == mainUtxoHash,
+                "Invalid main UTXO data"
+            );
+            resolvedMainUtxo = mainUtxo;
+        }
+    }
+
+    /// @notice Processes the Bitcoin moved funds sweep transaction input vector.
+    ///         It extracts the first input and tries to match it with one of
+    ///         the moved funds sweep requests targeting the sweeping wallet.
+    ///         If the sweep request is found and not yet processed, this
+    ///         function marks it as processed. If the sweeping wallet has a
+    ///         main UTXO, this function extracts the second input, makes sure
+    ///         it refers to the wallet main UTXO, and marks that main UTXO as
+    ///         correctly spent.
+    /// @param sweepTxInputVector Bitcoin moved funds 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 sweeping 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
+    /// @param walletPubKeyHash 20-byte public key hash of the sweeping wallet
+    /// @return inputsTotalValue Total inputs value sum.
+    /// @dev Requirements:
+    ///      - The input vector must consist of one mandatory and one optional
+    ///        input.
+    ///      - The mandatory input must be the first input in the vector
+    ///      - The mandatory input must point to a known moved funds sweep
+    ///        request that is not processed yet and is targeted to the sweeping
+    ///        wallet
+    ///      - The optional output must be the second input in the vector
+    ///      - The optional input is required if the sweeping wallet has a
+    ///        main UTXO (i.e. the `mainUtxo` is not zeroed). In that case,
+    ///        that input must point the the sweeping wallet main UTXO.
+    function processMovedFundsSweepTxInputs(
+        BridgeState.Storage storage self,
+        bytes memory sweepTxInputVector,
+        BitcoinTx.UTXO memory mainUtxo,
+        bytes20 walletPubKeyHash
+    ) internal returns (uint256 inputsTotalValue) {
+        // To determine the total number of Bitcoin transaction inputs,
+        // we need to parse the compactSize uint (VarInt) the input vector is
+        // prepended by. That compactSize uint encodes the number of vector
+        // elements using the format presented in:
+        // https://developer.bitcoin.org/reference/transactions.html#compactsize-unsigned-integers
+        // We don't need asserting the compactSize uint is parseable since it
+        // was already checked during `validateVin` validation performed as
+        // part of the `BitcoinTx.validateProof` call.
+        // See `BitcoinTx.inputVector` docs for more details.
+        (
+            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
+        // must be added because `BtcUtils.parseVarInt` does not include
+        // compactSize uint tag in the returned length.
+        //
+        // For >= 0 && <= 252, `BTCUtils.determineVarIntDataLengthAt`
+        // returns `0`, so we jump over one byte of compactSize uint.
+        //
+        // For >= 253 && <= 0xffff there is `0xfd` tag,
+        // `BTCUtils.determineVarIntDataLengthAt` returns `2` (no
+        // tag byte included) so we need to jump over 1+2 bytes of
+        // compactSize uint.
+        //
+        // Please refer `BTCUtils` library and compactSize uint
+        // docs in `BitcoinTx` library for more details.
+        uint256 inputStartingIndex = 1 + inputsCompactSizeUintLength;
+
+        // We always expect the first input to be the swept UTXO. Additionally,
+        // if the sweeping wallet has a main UTXO, that main UTXO should be
+        // pointed by the second input.
+        require(
+            inputsCount == (mainUtxo.txHash != bytes32(0) ? 2 : 1),
+            "Moved funds sweep transaction must have a proper inputs count"
+        );
+
+        // Parse the first input and extract its outpoint tx hash and index.
+        (
+            bytes32 firstInputOutpointTxHash,
+            uint32 firstInputOutpointIndex,
+            uint256 firstInputLength
+        ) = parseMovedFundsSweepTxInputAt(
+                sweepTxInputVector,
+                inputStartingIndex
+            );
+
+        // Build the request key and fetch the corresponding moved funds sweep
+        // request from contract storage.
+        MovedFundsSweepRequest storage sweepRequest = self
+            .movedFundsSweepRequests[
+                uint256(
+                    keccak256(
+                        abi.encodePacked(
+                            firstInputOutpointTxHash,
+                            firstInputOutpointIndex
+                        )
+                    )
+                )
+            ];
+
+        // The sweep request must exist, must be not processed yet, and must
+        // belong to the sweeping wallet.
+        require(sweepRequest.createdAt != 0, "Sweep request does not exist");
+        require(sweepRequest.sweptAt == 0, "Sweep request already processed");
+        // We must check if the wallet extracted from the moved funds sweep
+        // transaction output is truly the owner of the sweep request connected
+        // with the swept UTXO. This is needed to prevent a case when a wallet
+        // handles its own sweep request but locks the funds on another
+        // wallet public key hash.
+        require(
+            sweepRequest.walletPubKeyHash == walletPubKeyHash,
+            "Sweep request belongs to another wallet"
+        );
+        // If the validation passed, the sweep request must be marked as
+        // processed and its value should be counted into the total inputs
+        // value sum.
+        /* solhint-disable-next-line not-rely-on-time */
+        sweepRequest.sweptAt = uint32(block.timestamp);
+        inputsTotalValue += sweepRequest.value;
+
+        self
+            .registeredWallets[walletPubKeyHash]
+            .pendingMovedFundsSweepRequestsCount--;
+
+        // If the main UTXO for the sweeping wallet exists, it must be processed.
+        if (mainUtxo.txHash != bytes32(0)) {
+            // The second input is supposed to point to that sweeping wallet
+            // main UTXO. We need to parse that input.
+            (
+                bytes32 secondInputOutpointTxHash,
+                uint32 secondInputOutpointIndex,
+
+            ) = parseMovedFundsSweepTxInputAt(
+                    sweepTxInputVector,
+                    inputStartingIndex + firstInputLength
+                );
+            // Make sure the second input refers to the sweeping wallet main UTXO.
+            require(
+                mainUtxo.txHash == secondInputOutpointTxHash &&
+                    mainUtxo.txOutputIndex == secondInputOutpointIndex,
+                "Second input must point to the wallet's main UTXO"
+            );
+
+            // If the validation passed, count the main UTXO value into the
+            // total inputs value sum.
+            inputsTotalValue += mainUtxo.txOutputValue;
+
+            // Main UTXO used as an input, mark it as spent. This is needed
+            // to defend against fraud challenges referring to this main UTXO.
+            self.spentMainUTXOs[
+                uint256(
+                    keccak256(
+                        abi.encodePacked(
+                            secondInputOutpointTxHash,
+                            secondInputOutpointIndex
+                        )
+                    )
+                )
+            ] = true;
+        }
+
+        return inputsTotalValue;
+    }
+
+    /// @notice Parses a Bitcoin transaction input starting at the given index.
+    /// @param inputVector Bitcoin transaction input vector
+    /// @param inputStartingIndex Index the given input starts at
+    /// @return outpointTxHash 32-byte hash of the Bitcoin transaction which is
+    ///         pointed in the given input's outpoint.
+    /// @return outpointIndex 4-byte index of the Bitcoin transaction output
+    ///         which is pointed in the given input's outpoint.
+    /// @return inputLength Byte length of the given input.
+    /// @dev This function assumes vector's structure is valid so it must be
+    ///      validated using e.g. `BTCUtils.validateVin` function before it
+    ///      is passed here.
+    function parseMovedFundsSweepTxInputAt(
+        bytes memory inputVector,
+        uint256 inputStartingIndex
+    )
+        internal
+        pure
+        returns (
+            bytes32 outpointTxHash,
+            uint32 outpointIndex,
+            uint256 inputLength
+        )
+    {
+        outpointTxHash = inputVector.extractInputTxIdLeAt(inputStartingIndex);
+
+        outpointIndex = BTCUtils.reverseUint32(
+            uint32(inputVector.extractTxIndexLeAt(inputStartingIndex))
+        );
+
+        inputLength = inputVector.determineInputLengthAt(inputStartingIndex);
+
+        return (outpointTxHash, outpointIndex, inputLength);
+    }
 }

package/contracts/bridge/Wallets.sol

@@ -78,6 +78,8 @@ library Wallets {
         // UNIX timestamp indicating the moment the wallet's closing period
         // started.
         uint32 closingStartedAt;
+        // Total count of pending moved funds sweep requests targeting this wallet.
+        uint32 pendingMovedFundsSweepRequestsCount;
         // Current state of the wallet.
         WalletState state;
         // Moving funds target wallet commitment submitted by the wallet. It

package/deploy/05_deploy_bridge.ts

@@ -19,7 +19,10 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     deployments.getNetworkName() === "hardhat" ? 1 : 6
 
   const Deposit = await deploy("Deposit", { from: deployer, log: true })
-  const Sweep = await deploy("Sweep", { from: deployer, log: true })
+  const DepositSweep = await deploy("DepositSweep", {
+    from: deployer,
+    log: true,
+  })
   const Redemption = await deploy("Redemption", { from: deployer, log: true })
   const Wallets = await deploy("Wallets", { from: deployer, log: true })
   const Fraud = await deploy("Fraud", { from: deployer, log: true })
@@ -41,7 +44,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     ],
     libraries: {
       Deposit: Deposit.address,
-      Sweep: Sweep.address,
+      DepositSweep: DepositSweep.address,
       Redemption: Redemption.address,
       Wallets: Wallets.address,
       Fraud: Fraud.address,