@keep-network/tbtc-v2 0.1.1-dev.40 → 0.1.1-dev.43

package/contracts/bridge/{Frauds.sol → Fraud.sol}

@@ -18,32 +18,35 @@ pragma solidity ^0.8.9;
 import {BytesLib} from "@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol";
 import {BTCUtils} from "@keep-network/bitcoin-spv-sol/contracts/BTCUtils.sol";
 import {CheckBitcoinSigs} from "@keep-network/bitcoin-spv-sol/contracts/CheckBitcoinSigs.sol";
+
 import "./BitcoinTx.sol";
 import "./EcdsaLib.sol";
-import "./Bridge.sol";
-
-library Frauds {
+import "./BridgeState.sol";
+import "./Wallets.sol";
+
+/// @title Bridge fraud
+/// @notice The library handles the logic for challenging Bridge wallets that
+///         committed fraud.
+/// @dev Anyone can submit a fraud challenge indicating that a UTXO being under
+///      the wallet control was unlocked by the wallet but was not used
+///      according to the protocol rules. That means the wallet signed
+///      a transaction input pointing to that UTXO and there is a unique
+///      sighash and signature pair associated with that input.
+///
+///      In order to defeat the challenge, the same wallet public key and
+///      signature must be provided as were used to calculate the sighash during
+///      the challenge. The wallet provides the preimage which produces sighash
+///      used to generate the ECDSA signature that is the subject of the fraud
+///      claim. The fraud challenge defeat attempt will only succeed if the
+///      inputs in the preimage are considered honestly spent by the wallet.
+///      Therefore the transaction spending the UTXO must be proven in the
+///      Bridge before a challenge defeat is called.
+library Fraud {
     using BytesLib for bytes;
     using BTCUtils for bytes;
     using BTCUtils for uint32;
     using EcdsaLib for bytes;
 
-    struct Data {
-        ///  The amount of stake slashed from each member of a wallet for a fraud.
-        uint256 slashingAmount;
-        /// The percentage of the notifier reward from the staking contract
-        /// the notifier of a fraud receives. The value is in the range [0, 100].
-        uint256 notifierRewardMultiplier;
-        /// The amount of time the wallet has to defeat a fraud challenge.
-        uint256 challengeDefeatTimeout;
-        /// The amount of ETH in wei the party challenging the wallet for fraud
-        /// needs to deposit.
-        uint256 challengeDepositAmount;
-        /// Collection of all submitted fraud challenges indexed by challenge
-        /// key built as keccak256(walletPublicKey|sighash).
-        mapping(uint256 => FraudChallenge) challenges;
-    }
-
     struct FraudChallenge {
         // The address of the party challenging the wallet.
         address challenger;
@@ -55,20 +58,6 @@ library Frauds {
         bool resolved;
     }
 
-    event FraudSlashingAmountUpdated(uint256 newFraudSlashingAmount);
-
-    event FraudNotifierRewardMultiplierUpdated(
-        uint256 newFraudNotifierRewardMultiplier
-    );
-
-    event FraudChallengeDefeatTimeoutUpdated(
-        uint256 newFraudChallengeDefeatTimeout
-    );
-
-    event FraudChallengeDepositAmountUpdated(
-        uint256 newFraudChallengeDepositAmount
-    );
-
     event FraudChallengeSubmitted(
         bytes20 walletPublicKeyHash,
         bytes32 sighash,
@@ -101,8 +90,6 @@ library Frauds {
     ///         challenge or confiscated otherwise
     /// @param walletPublicKey The public key of the wallet in the uncompressed
     ///        and unprefixed format (64 bytes)
-    /// @param walletPubKeyHash 20-byte public key hash (computed using Bitcoin
-    //         HASH160 over the compressed ECDSA public key) of the wallet
     /// @param sighash The hash that was used to produce the ECDSA signature
     ///        that is the subject of the fraud claim. This hash is constructed
     ///        by applying double SHA-256 over a serialized subset of the
@@ -111,20 +98,21 @@ library Frauds {
     ///        for reference
     /// @param signature Bitcoin signature in the R/S/V format
     /// @dev Requirements:
+    ///      - Wallet behind `walletPublicKey` must be in `Live` or `MovingFunds`
+    ///        state
     ///      - The challenger must send appropriate amount of ETH used as
     ///        fraud challenge deposit
     ///      - The signature (represented by r, s and v) must be generated by
-    ///        the wallet behind `walletPubKey` during signing of `sighash`
+    ///        the wallet behind `walletPublicKey` during signing of `sighash`
     ///      - Wallet can be challenged for the given signature only once
-    function submitChallenge(
-        Data storage self,
+    function submitFraudChallenge(
+        BridgeState.Storage storage self,
         bytes calldata walletPublicKey,
-        bytes20 walletPubKeyHash,
         bytes32 sighash,
         BitcoinTx.RSVSignature calldata signature
     ) external {
         require(
-            msg.value >= self.challengeDepositAmount,
+            msg.value >= self.fraudChallengeDepositAmount,
             "The amount of ETH deposited is too low"
         );
 
@@ -139,11 +127,27 @@ library Frauds {
             "Signature verification failure"
         );
 
+        bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(
+            walletPublicKey.slice32(0),
+            walletPublicKey.slice32(32)
+        );
+        bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();
+
+        Wallets.Wallet storage wallet = self.registeredWallets[
+            walletPubKeyHash
+        ];
+
+        require(
+            wallet.state == Wallets.WalletState.Live ||
+                wallet.state == Wallets.WalletState.MovingFunds,
+            "Wallet is neither in Live nor MovingFunds state"
+        );
+
         uint256 challengeKey = uint256(
             keccak256(abi.encodePacked(walletPublicKey, sighash))
         );
 
-        FraudChallenge storage challenge = self.challenges[challengeKey];
+        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];
         require(challenge.reportedAt == 0, "Fraud challenge already exists");
 
         challenge.challenger = msg.sender;
@@ -161,8 +165,18 @@ library Frauds {
         );
     }
 
-    /// @notice Unwraps the fraud challenge by verifying the given challenge
-    ///         and returns the UTXO key extracted from the preimage.
+    /// @notice Allows to defeat a pending fraud challenge against a wallet if
+    ///         the transaction that spends the UTXO follows the protocol rules.
+    ///         In order to defeat the challenge the same `walletPublicKey` and
+    ///         signature (represented by `r`, `s` and `v`) must be provided as
+    ///         were used to calculate the sighash during input signing.
+    ///         The fraud challenge defeat attempt will only succeed if the
+    ///         inputs in the preimage are considered honestly spent by the
+    ///         wallet. Therefore the transaction spending the UTXO must be
+    ///         proven in the Bridge before a challenge defeat is called.
+    ///         If successfully defeated, the fraud challenge is marked as
+    ///         resolved and the amount of ether deposited by the challenger is
+    ///         sent to the treasury.
     /// @param walletPublicKey The public key of the wallet in the uncompressed
     ///        and unprefixed format (64 bytes)
     /// @param preimage The preimage which produces sighash used to generate the
@@ -172,25 +186,26 @@ library Frauds {
     ///        produced for. See BIP-143 for reference
     /// @param witness Flag indicating whether the preimage was produced for a
     ///        witness input. True for witness, false for non-witness input.
-    /// @return utxoKey UTXO key that identifies spent input.
     /// @dev Requirements:
     ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`
     ///        must identify an open fraud challenge
     ///      - the preimage must be a valid preimage of a transaction generated
     ///        according to the protocol rules and already proved in the Bridge
-    function unwrapChallenge(
-        Data storage self,
+    ///      - before a defeat attempt is made the transaction that spends the
+    ///        given UTXO must be proven in the Bridge
+    function defeatFraudChallenge(
+        BridgeState.Storage storage self,
         bytes calldata walletPublicKey,
         bytes calldata preimage,
         bool witness
-    ) external returns (uint256 utxoKey) {
+    ) external {
         bytes32 sighash = preimage.hash256();
 
         uint256 challengeKey = uint256(
             keccak256(abi.encodePacked(walletPublicKey, sighash))
         );
 
-        FraudChallenge storage challenge = self.challenges[challengeKey];
+        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];
 
         require(challenge.reportedAt > 0, "Fraud challenge does not exist");
         require(
@@ -202,55 +217,23 @@ library Frauds {
         // by type value `1`.
         require(extractSighashType(preimage) == 1, "Wrong sighash type");
 
-        return
-            witness
-                ? extractUtxoKeyFromWitnessPreimage(preimage)
-                : extractUtxoKeyFromNonWitnessPreimage(preimage);
-    }
-
-    /// @notice Finalizes fraud challenge defeat by marking a pending fraud
-    ///         challenge against the wallet as resolved and sending the ether
-    ///         deposited by the challenger to the treasury.
-    ///         In order to finalize the challenge defeat the same
-    ///         `walletPublicKey` must be provided as was used in the fraud
-    ///         challenge. Additionally a preimage must be provided which was
-    ///         used to calculate the sighash during input signing.
-    /// @param walletPublicKey The public key of the wallet in the uncompressed
-    ///        and unprefixed format (64 bytes)
-    /// @param preimage The preimage which produces sighash used to generate the
-    ///        ECDSA signature that is the subject of the fraud claim. It is a
-    ///        serialized subset of the transaction. The exact subset used as
-    ///        the preimage depends on the transaction input the signature is
-    ///        produced for. See BIP-143 for reference
-    /// @param treasury Treasury associated with the Bridge
-    /// @dev Requirements:
-    ///      - `walletPublicKey` and `sighash` calculated as `hash256(preimage)`
-    ///        must identify an open fraud challenge
-    ///      - the preimage must be a valid preimage of a transaction generated
-    ///        according to the protocol rules and already proved in the Bridge
-    ///      - before a defeat attempt is made the transaction that spends the
-    ///        given UTXO must be proven in the Bridge
-    function defeatChallenge(
-        Data storage self,
-        bytes calldata walletPublicKey,
-        bytes calldata preimage,
-        address treasury
-    ) external {
-        bytes32 sighash = preimage.hash256();
+        uint256 utxoKey = witness
+            ? extractUtxoKeyFromWitnessPreimage(preimage)
+            : extractUtxoKeyFromNonWitnessPreimage(preimage);
 
-        uint256 challengeKey = uint256(
-            keccak256(abi.encodePacked(walletPublicKey, sighash))
+        // Check that the UTXO key identifies a correctly spent UTXO.
+        require(
+            self.deposits[utxoKey].sweptAt > 0 || self.spentMainUTXOs[utxoKey],
+            "Spent UTXO not found among correctly spent UTXOs"
         );
 
-        FraudChallenge storage challenge = self.challenges[challengeKey];
-
         // Mark the challenge as resolved as it was successfully defeated
         challenge.resolved = true;
 
         // Send the ether deposited by the challenger to the treasury
         /* solhint-disable avoid-low-level-calls */
         // slither-disable-next-line low-level-calls
-        treasury.call{gas: 100000, value: challenge.depositAmount}("");
+        self.treasury.call{gas: 100000, value: challenge.depositAmount}("");
         /* solhint-enable avoid-low-level-calls */
 
         bytes memory compressedWalletPublicKey = EcdsaLib.compressPublicKey(
@@ -285,8 +268,8 @@ library Frauds {
     ///        challenge
     ///      - the amount of time indicated by `challengeDefeatTimeout` must pass
     ///        after the challenge was reported
-    function notifyChallengeDefeatTimeout(
-        Data storage self,
+    function notifyFraudChallengeDefeatTimeout(
+        BridgeState.Storage storage self,
         bytes calldata walletPublicKey,
         bytes32 sighash
     ) external {
@@ -294,7 +277,7 @@ library Frauds {
             keccak256(abi.encodePacked(walletPublicKey, sighash))
         );
 
-        FraudChallenge storage challenge = self.challenges[challengeKey];
+        FraudChallenge storage challenge = self.fraudChallenges[challengeKey];
         require(challenge.reportedAt > 0, "Fraud challenge does not exist");
         require(
             !challenge.resolved,
@@ -303,7 +286,7 @@ library Frauds {
         require(
             /* solhint-disable-next-line not-rely-on-time */
             block.timestamp >=
-                challenge.reportedAt + self.challengeDefeatTimeout,
+                challenge.reportedAt + self.fraudChallengeDefeatTimeout,
             "Fraud challenge defeat period did not time out yet"
         );
 
@@ -329,60 +312,6 @@ library Frauds {
         emit FraudChallengeDefeatTimedOut(walletPubKeyHash, sighash);
     }
 
-    /// @notice Sets the new value for the `slashingAmount` parameter.
-    /// @param _newSlashingAmount the new value for `slashingAmount`
-    function setSlashingAmount(Data storage self, uint256 _newSlashingAmount)
-        external
-    {
-        self.slashingAmount = _newSlashingAmount;
-        emit FraudSlashingAmountUpdated(_newSlashingAmount);
-    }
-
-    /// @notice Sets the new value for the `notifierRewardMultiplier` parameter.
-    /// @param _newNotifierRewardMultiplier the new value for `notifierRewardMultiplier`
-    /// @dev The value of `notifierRewardMultiplier` must be <= 100.
-    function setNotifierRewardMultiplier(
-        Data storage self,
-        uint256 _newNotifierRewardMultiplier
-    ) external {
-        require(
-            _newNotifierRewardMultiplier <= 100,
-            "Fraud notifier reward multiplier must be <= 100"
-        );
-        self.notifierRewardMultiplier = _newNotifierRewardMultiplier;
-        emit FraudNotifierRewardMultiplierUpdated(_newNotifierRewardMultiplier);
-    }
-
-    /// @notice Sets the new value for the `challengeDefeatTimeout` parameter.
-    /// @param _newChallengeDefeatTimeout the new value for `challengeDefeatTimeout`
-    /// @dev The value of `challengeDefeatTimeout` must be > 0.
-    function setChallengeDefeatTimeout(
-        Data storage self,
-        uint256 _newChallengeDefeatTimeout
-    ) external {
-        require(
-            _newChallengeDefeatTimeout > 0,
-            "Fraud challenge defeat timeout must be > 0"
-        );
-        self.challengeDefeatTimeout = _newChallengeDefeatTimeout;
-        emit FraudChallengeDefeatTimeoutUpdated(_newChallengeDefeatTimeout);
-    }
-
-    /// @notice Sets the new value for the `challengeDepositAmount` parameter.
-    /// @param _newChallengeDepositAmount the new value for `challengeDepositAmount`
-    /// @dev The value of `challengeDepositAmount` must be > 0.
-    function setChallengeDepositAmount(
-        Data storage self,
-        uint256 _newChallengeDepositAmount
-    ) external {
-        require(
-            _newChallengeDepositAmount > 0,
-            "Fraud challenge deposit amount must be > 0"
-        );
-        self.challengeDepositAmount = _newChallengeDepositAmount;
-        emit FraudChallengeDepositAmountUpdated(_newChallengeDepositAmount);
-    }
-
     /// @notice Extracts the UTXO keys from the given preimage used during
     ///         signing of a witness input.
     /// @param preimage The preimage which produces sighash used to generate the

package/contracts/bridge/MovingFunds.sol

@@ -20,11 +20,20 @@ import {BytesLib} from "@keep-network/bitcoin-spv-sol/contracts/BytesLib.sol";
 
 import "./BitcoinTx.sol";
 import "./BridgeState.sol";
-import "./Redeem.sol";
+import "./Redemption.sol";
 
+/// @title Moving Bridge wallet funds
+/// @notice The library handles the logic for moving Bitcoin between Bridge
+///         wallets.
+/// @dev A wallet that failed a heartbeat, did not process requested redemption
+///      on time, or qualifies to be closed, begins the procedure of moving
+///      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.
 library MovingFunds {
     using BridgeState for BridgeState.Storage;
-    using Wallets for Wallets.Data;
+    using Wallets for BridgeState.Storage;
+    using BitcoinTx for BridgeState.Storage;
 
     using BTCUtils for bytes;
     using BytesLib for bytes;
@@ -81,7 +90,6 @@ library MovingFunds {
     ///        to `movingFundsTxMaxTotalFee` governable parameter.
     function submitMovingFundsProof(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         BitcoinTx.Info calldata movingFundsTx,
         BitcoinTx.Proof calldata movingFundsProof,
         BitcoinTx.UTXO calldata mainUtxo,
@@ -91,17 +99,15 @@ library MovingFunds {
         // can assume the transaction happened on Bitcoin chain and has
         // a sufficient number of confirmations as determined by
         // `txProofDifficultyFactor` constant.
-        bytes32 movingFundsTxHash = BitcoinTx.validateProof(
+        bytes32 movingFundsTxHash = self.validateProof(
             movingFundsTx,
-            movingFundsProof,
-            self.proofDifficultyContext()
+            movingFundsProof
         );
 
         // Process the moving funds transaction input. Specifically, check if
         // it refers to the expected wallet's main UTXO.
         OutboundTx.processWalletOutboundTxInput(
             self,
-            wallets,
             movingFundsTx.inputVector,
             mainUtxo,
             walletPubKeyHash
@@ -118,7 +124,7 @@ library MovingFunds {
             "Transaction fee is too high"
         );
 
-        wallets.notifyFundsMoved(walletPubKeyHash, targetWalletsHash);
+        self.notifyWalletFundsMoved(walletPubKeyHash, targetWalletsHash);
 
         emit MovingFundsCompleted(walletPubKeyHash, movingFundsTxHash);
     }
@@ -139,7 +145,7 @@ library MovingFunds {
     ///      - The total outputs value must be evenly divided over all outputs.
     function processMovingFundsTxOutputs(bytes memory movingFundsTxOutputVector)
         internal
-        view
+        pure
         returns (bytes32 targetWalletsHash, uint256 outputsTotalValue)
     {
         // Determining the total number of Bitcoin transaction outputs in

package/contracts/bridge/{Redeem.sol → Redemption.sol}

@@ -47,13 +47,12 @@ library OutboundTx {
     ///        performed the outbound transaction.
     function processWalletOutboundTxInput(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         bytes memory walletOutboundTxInputVector,
         BitcoinTx.UTXO calldata mainUtxo,
         bytes20 walletPubKeyHash
     ) internal {
         // Assert that main UTXO for passed wallet exists in storage.
-        bytes32 mainUtxoHash = wallets
+        bytes32 mainUtxoHash = self
             .registeredWallets[walletPubKeyHash]
             .mainUtxoHash;
         require(mainUtxoHash != bytes32(0), "No main UTXO for given wallet");
@@ -141,10 +140,18 @@ library OutboundTx {
     }
 }
 
-// TODO: Rename to Redemption. All library names are nouns.
-library Redeem {
+/// @title Bridge redemption
+/// @notice The library handles the logic for redeeming Bitcoin balances from
+///         the Bridge.
+/// @dev To initiate a redemption, a user with a Bank balance supplies
+///      a Bitcoin address. Then, the system calculates the redemption fee, and
+///      releases balance to the provided Bitcoin address. Just like in case of
+///      sweeps of revealed deposits, redemption requests are processed in
+///      batches and require SPV proof to be submitted to the Bridge.
+library Redemption {
     using BridgeState for BridgeState.Storage;
-    using Wallets for Wallets.Data;
+    using Wallets for BridgeState.Storage;
+    using BitcoinTx for BridgeState.Storage;
 
     using BTCUtils for bytes;
     using BytesLib for bytes;
@@ -248,13 +255,12 @@ library Redeem {
     ///        contract can spend the given `amount`.
     function requestRedemption(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         bytes20 walletPubKeyHash,
         BitcoinTx.UTXO calldata mainUtxo,
         bytes calldata redeemerOutputScript,
         uint64 amount
     ) external {
-        Wallets.Wallet storage wallet = wallets.registeredWallets[
+        Wallets.Wallet storage wallet = self.registeredWallets[
             walletPubKeyHash
         ];
 
@@ -419,7 +425,6 @@ library Redeem {
     ///        is identified, that check is omitted in further iterations.
     function submitRedemptionProof(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         BitcoinTx.Info calldata redemptionTx,
         BitcoinTx.Proof calldata redemptionProof,
         BitcoinTx.UTXO calldata mainUtxo,
@@ -433,23 +438,21 @@ library Redeem {
         // can assume the transaction happened on Bitcoin chain and has
         // a sufficient number of confirmations as determined by
         // `txProofDifficultyFactor` constant.
-        bytes32 redemptionTxHash = BitcoinTx.validateProof(
+        bytes32 redemptionTxHash = self.validateProof(
             redemptionTx,
-            redemptionProof,
-            self.proofDifficultyContext()
+            redemptionProof
         );
 
         // Process the redemption transaction input. Specifically, check if it
         // refers to the expected wallet's main UTXO.
         OutboundTx.processWalletOutboundTxInput(
             self,
-            wallets,
             redemptionTx.inputVector,
             mainUtxo,
             walletPubKeyHash
         );
 
-        Wallets.Wallet storage wallet = wallets.registeredWallets[
+        Wallets.Wallet storage wallet = self.registeredWallets[
             walletPubKeyHash
         ];
 
@@ -789,14 +792,13 @@ library Redeem {
     ///        timed-out).
     function notifyRedemptionTimeout(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         bytes20 walletPubKeyHash,
         bytes calldata redeemerOutputScript
     ) external {
         uint256 redemptionKey = uint256(
             keccak256(abi.encodePacked(walletPubKeyHash, redeemerOutputScript))
         );
-        Redeem.RedemptionRequest memory request = self.pendingRedemptions[
+        Redemption.RedemptionRequest memory request = self.pendingRedemptions[
             redemptionKey
         ];
 
@@ -808,7 +810,7 @@ library Redeem {
         );
 
         // Update the wallet's pending redemptions value
-        Wallets.Wallet storage wallet = wallets.registeredWallets[
+        Wallets.Wallet storage wallet = self.registeredWallets[
             walletPubKeyHash
         ];
         wallet.pendingRedemptionsValue -=
@@ -838,7 +840,7 @@ library Redeem {
             wallet.state == Wallets.WalletState.MovingFunds
         ) {
             // Propagate timeout consequences to the wallet
-            wallets.notifyRedemptionTimedOut(walletPubKeyHash);
+            self.notifyWalletTimedOutRedemption(walletPubKeyHash);
         }
 
         emit RedemptionTimedOut(walletPubKeyHash, redeemerOutputScript);

package/contracts/bridge/Sweep.sol

@@ -23,8 +23,19 @@ import "./Wallets.sol";
 
 import "../bank/Bank.sol";
 
+/// @title Bridge deposit sweep
+/// @notice The library handles the logic for sweeping transactions revealed to
+///         the Bridge
+/// @dev Bridge active wallet periodically signs a transaction that unlocks all
+///      of the valid, revealed deposits above the dust threshold, combines them
+///      into a single UTXO with the existing main wallet UTXO, and relocks
+///      those transactions without a 30-day refund clause to the same wallet.
+///      This has two main effects: it consolidates the UTXO set and it disables
+///      the refund. Balances of depositors in the Bank are increased when the
+///      SPV sweep proof is submitted to the Bridge.
 library Sweep {
     using BridgeState for BridgeState.Storage;
+    using BitcoinTx for BridgeState.Storage;
 
     using BTCUtils for bytes;
 
@@ -94,7 +105,6 @@ library Sweep {
     ///        If there is no main UTXO, this parameter is ignored.
     function submitSweepProof(
         BridgeState.Storage storage self,
-        Wallets.Data storage wallets,
         BitcoinTx.Info calldata sweepTx,
         BitcoinTx.Proof calldata sweepProof,
         BitcoinTx.UTXO calldata mainUtxo
@@ -106,11 +116,7 @@ library Sweep {
         // can assume the transaction happened on Bitcoin chain and has
         // a sufficient number of confirmations as determined by
         // `txProofDifficultyFactor` constant.
-        bytes32 sweepTxHash = BitcoinTx.validateProof(
-            sweepTx,
-            sweepProof,
-            self.proofDifficultyContext()
-        );
+        bytes32 sweepTxHash = self.validateProof(sweepTx, sweepProof);
 
         // Process sweep transaction output and extract its target wallet
         // public key hash and value.
@@ -122,7 +128,7 @@ library Sweep {
         (
             Wallets.Wallet storage wallet,
             BitcoinTx.UTXO memory resolvedMainUtxo
-        ) = resolveSweepingWallet(wallets, walletPubKeyHash, mainUtxo);
+        ) = resolveSweepingWallet(self, walletPubKeyHash, mainUtxo);
 
         // Process sweep transaction inputs and extract all information needed
         // to perform deposit bookkeeping.
@@ -208,17 +214,18 @@ library Sweep {
     ///     - If the main UTXO of the sweeping wallet exists in the storage,
     ///       the passed `mainUTXO` parameter must be equal to the stored one.
     function resolveSweepingWallet(
-        Wallets.Data storage wallets,
+        BridgeState.Storage storage self,
         bytes20 walletPubKeyHash,
         BitcoinTx.UTXO calldata mainUtxo
     )
         internal
+        view
         returns (
             Wallets.Wallet storage wallet,
             BitcoinTx.UTXO memory resolvedMainUtxo
         )
     {
-        wallet = wallets.registeredWallets[walletPubKeyHash];
+        wallet = self.registeredWallets[walletPubKeyHash];
 
         Wallets.WalletState walletState = wallet.state;
         require(