@keep-network/tbtc-v2 0.1.1-dev.95 → 0.1.1-dev.98

package/contracts/bridge/Bridge.sol

@@ -239,7 +239,7 @@ contract Bridge is
         address _relay,
         address _treasury,
         address _ecdsaWalletRegistry,
-        uint256 _txProofDifficultyFactor
+        uint96 _txProofDifficultyFactor
     ) external initializer {
         require(_bank != address(0), "Bank address cannot be zero");
         self.bank = Bank(_bank);
@@ -944,11 +944,11 @@ contract Bridge is
     ///        can be empty as it is ignored since the wallet balance is
     ///        assumed to be zero,
     ///      - Wallet must be in Live state.
-    function notifyCloseableWallet(
+    function notifyWalletCloseable(
         bytes20 walletPubKeyHash,
         BitcoinTx.UTXO calldata walletMainUtxo
     ) external {
-        self.notifyCloseableWallet(walletPubKeyHash, walletMainUtxo);
+        self.notifyWalletCloseable(walletPubKeyHash, walletMainUtxo);
     }
 
     /// @notice Notifies about the end of the closing period for the given wallet.
@@ -1228,9 +1228,9 @@ contract Bridge is
         uint64 redemptionDustThreshold,
         uint64 redemptionTreasuryFeeDivisor,
         uint64 redemptionTxMaxFee,
-        uint256 redemptionTimeout,
+        uint64 redemptionTimeout,
         uint96 redemptionTimeoutSlashingAmount,
-        uint256 redemptionTimeoutNotifierRewardMultiplier
+        uint64 redemptionTimeoutNotifierRewardMultiplier
     ) external onlyGovernance {
         self.updateRedemptionParameters(
             redemptionDustThreshold,
@@ -1315,7 +1315,7 @@ contract Bridge is
         uint64 movedFundsSweepTxMaxTotalFee,
         uint32 movedFundsSweepTimeout,
         uint96 movedFundsSweepTimeoutSlashingAmount,
-        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier
+        uint64 movedFundsSweepTimeoutNotifierRewardMultiplier
     ) external onlyGovernance {
         self.updateMovingFundsParameters(
             movingFundsTxMaxTotalFee,
@@ -1395,10 +1395,10 @@ contract Bridge is
     ///      - Fraud challenge defeat timeout must be greater than 0,
     ///      - Fraud notifier reward multiplier must be in the range [0, 100].
     function updateFraudParameters(
-        uint256 fraudChallengeDepositAmount,
-        uint256 fraudChallengeDefeatTimeout,
+        uint96 fraudChallengeDepositAmount,
+        uint32 fraudChallengeDefeatTimeout,
         uint96 fraudSlashingAmount,
-        uint256 fraudNotifierRewardMultiplier
+        uint32 fraudNotifierRewardMultiplier
     ) external onlyGovernance {
         self.updateFraudParameters(
             fraudChallengeDepositAmount,
@@ -1607,9 +1607,9 @@ contract Bridge is
             uint64 redemptionDustThreshold,
             uint64 redemptionTreasuryFeeDivisor,
             uint64 redemptionTxMaxFee,
-            uint256 redemptionTimeout,
+            uint64 redemptionTimeout,
             uint96 redemptionTimeoutSlashingAmount,
-            uint256 redemptionTimeoutNotifierRewardMultiplier
+            uint64 redemptionTimeoutNotifierRewardMultiplier
         )
     {
         redemptionDustThreshold = self.redemptionDustThreshold;
@@ -1748,10 +1748,10 @@ contract Bridge is
         external
         view
         returns (
-            uint256 fraudChallengeDepositAmount,
-            uint256 fraudChallengeDefeatTimeout,
+            uint96 fraudChallengeDepositAmount,
+            uint32 fraudChallengeDefeatTimeout,
             uint96 fraudSlashingAmount,
-            uint256 fraudNotifierRewardMultiplier
+            uint32 fraudNotifierRewardMultiplier
         )
     {
         fraudChallengeDepositAmount = self.fraudChallengeDepositAmount;

package/contracts/bridge/BridgeState.sol

@@ -32,11 +32,11 @@ library BridgeState {
         Bank bank;
         // Bitcoin relay providing the current Bitcoin network difficulty.
         IRelay relay;
-        // ECDSA Wallet Registry contract handle.
-        EcdsaWalletRegistry ecdsaWalletRegistry;
         // The number of confirmations on the Bitcoin chain required to
         // successfully evaluate an SPV proof.
-        uint256 txProofDifficultyFactor;
+        uint96 txProofDifficultyFactor;
+        // ECDSA Wallet Registry contract handle.
+        EcdsaWalletRegistry ecdsaWalletRegistry;
         // Address where the deposit and redemption treasury fees will be sent
         // to. Treasury takes part in the operators rewarding process.
         address treasury;
@@ -61,20 +61,10 @@ library BridgeState {
         //
         // This is a per-deposit input max fee for the sweep transaction.
         uint64 depositTxMaxFee;
-        // Collection of all revealed deposits indexed by
-        // `keccak256(fundingTxHash | fundingOutputIndex)`.
-        // The `fundingTxHash` is `bytes32` (ordered as in Bitcoin internally)
-        // and `fundingOutputIndex` an `uint32`. This mapping may contain valid
-        // and invalid deposits and the wallet is responsible for validating
-        // them before attempting to execute a sweep.
-        mapping(uint256 => Deposit.DepositRequest) deposits;
-        // Indicates if the vault with the given address is trusted or not.
-        // Depositors can route their revealed deposits only to trusted vaults
-        // and have trusted vaults notified about new deposits as soon as these
-        // deposits get swept. Vaults not trusted by the Bridge can still be
-        // used by Bank balance owners on their own responsibility - anyone can
-        // approve their Bank balance to any address.
-        mapping(address => bool) isVaultTrusted;
+        // Move movingFundsTxMaxTotalFee to the next storage slot for a more
+        // efficient variable layout
+        // slither-disable-next-line unused-state
+        bytes8 __depositAlignmentGap;
         // Maximum amount of the total BTC transaction fee that is acceptable in
         // a single moving funds transaction.
         //
@@ -129,14 +119,7 @@ library BridgeState {
         // The percentage of the notifier reward from the staking contract
         // the notifier of a moved funds sweep timeout receives. The value is
         // in the range [0, 100].
-        uint256 movedFundsSweepTimeoutNotifierRewardMultiplier;
-        // Collection of all moved funds sweep requests indexed by
-        // `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.
-        // The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin
-        // internally) and `movingFundsOutputIndex` an `uint32`. Each entry
-        // is actually an UTXO representing the moved funds and is supposed
-        // to be swept with the current main UTXO of the recipient wallet.
-        mapping(uint256 => MovingFunds.MovedFundsSweepRequest) movedFundsSweepRequests;
+        uint64 movedFundsSweepTimeoutNotifierRewardMultiplier;
         // The minimal amount that can be requested for redemption.
         // Value of this parameter must take into account the value of
         // `redemptionTreasuryFeeDivisor` and `redemptionTxMaxFee`
@@ -162,68 +145,33 @@ library BridgeState {
         // This is a per-redemption output max fee for the redemption
         // transaction.
         uint64 redemptionTxMaxFee;
+        // Move redemptionTimeout to the next storage slot for a more efficient
+        // variable layout
+        // slither-disable-next-line unused-state
+        bytes8 __redemptionAlignmentGap;
         // Time after which the redemption request can be reported as
         // timed out. It is counted from the moment when the redemption
         // request was created via `requestRedemption` call. Reported
         // timed out requests are cancelled and locked TBTC is returned
         // to the redeemer in full amount.
-        uint256 redemptionTimeout;
+        uint64 redemptionTimeout;
         // The amount of stake slashed from each member of a wallet for a
         // redemption timeout.
         uint96 redemptionTimeoutSlashingAmount;
         // The percentage of the notifier reward from the staking contract
         // the notifier of a redemption timeout receives. The value is in the
         // range [0, 100].
-        uint256 redemptionTimeoutNotifierRewardMultiplier;
-        // Collection of all pending redemption requests indexed by
-        // redemption key built as
-        // `keccak256(walletPubKeyHash | redeemerOutputScript)`.
-        // The `walletPubKeyHash` is the 20-byte wallet's public key hash
-        // (computed using Bitcoin HASH160 over the compressed ECDSA
-        // public key) and `redeemerOutputScript` is a Bitcoin script
-        // (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
-        // redeemed BTC as requested by the redeemer. Requests are added
-        // to this mapping by the `requestRedemption` method (duplicates
-        // not allowed) and are removed by one of the following methods:
-        // - `submitRedemptionProof` in case the request was handled
-        //    successfully,
-        // - `notifyRedemptionTimeout` in case the request was reported
-        //    to be timed out.
-        mapping(uint256 => Redemption.RedemptionRequest) pendingRedemptions;
-        // Collection of all timed out redemptions requests indexed by
-        // redemption key built as
-        // `keccak256(walletPubKeyHash | redeemerOutputScript)`. The
-        // `walletPubKeyHash` is the 20-byte wallet's public key hash
-        // (computed using Bitcoin HASH160 over the compressed ECDSA
-        // public key) and `redeemerOutputScript` is the Bitcoin script
-        // (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed
-        // out request. Timed out requests are stored in this mapping to
-        // avoid slashing the wallets multiple times for the same timeout.
-        // Only one method can add to this mapping:
-        // - `notifyRedemptionTimeout` which puts the redemption key to this
-        //    mapping basing on a timed out request stored previously in
-        //    `pendingRedemptions` mapping.
-        mapping(uint256 => Redemption.RedemptionRequest) timedOutRedemptions;
+        uint64 redemptionTimeoutNotifierRewardMultiplier;
         // The amount of ETH in wei the party challenging the wallet for fraud
         // needs to deposit.
-        uint256 fraudChallengeDepositAmount;
+        uint96 fraudChallengeDepositAmount;
         // The amount of time the wallet has to defeat a fraud challenge.
-        uint256 fraudChallengeDefeatTimeout;
+        uint32 fraudChallengeDefeatTimeout;
         // The amount of stake slashed from each member of a wallet for a fraud.
         uint96 fraudSlashingAmount;
         // 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 fraudNotifierRewardMultiplier;
-        // Collection of all submitted fraud challenges indexed by challenge
-        // key built as `keccak256(walletPublicKey|sighash)`.
-        mapping(uint256 => Fraud.FraudChallenge) fraudChallenges;
-        // Collection of main UTXOs that are honestly spent indexed by
-        // `keccak256(fundingTxHash | fundingOutputIndex)`. The `fundingTxHash`
-        // is `bytes32` (ordered as in Bitcoin internally) and
-        // `fundingOutputIndex` an `uint32`. A main UTXO is considered honestly
-        // spent if it was used as an input of a transaction that have been
-        // proven in the Bridge.
-        mapping(uint256 => bool) spentMainUTXOs;
+        uint32 fraudNotifierRewardMultiplier;
         // Determines how frequently a new wallet creation can be requested.
         // Value in seconds.
         uint32 walletCreationPeriod;
@@ -259,6 +207,66 @@ library BridgeState {
         // of deposit fraud challenges. This value is in seconds and should be
         // greater than the deposit refund time plus some time margin.
         uint32 walletClosingPeriod;
+        // Collection of all revealed deposits indexed by
+        // `keccak256(fundingTxHash | fundingOutputIndex)`.
+        // The `fundingTxHash` is `bytes32` (ordered as in Bitcoin internally)
+        // and `fundingOutputIndex` an `uint32`. This mapping may contain valid
+        // and invalid deposits and the wallet is responsible for validating
+        // them before attempting to execute a sweep.
+        mapping(uint256 => Deposit.DepositRequest) deposits;
+        // Indicates if the vault with the given address is trusted or not.
+        // Depositors can route their revealed deposits only to trusted vaults
+        // and have trusted vaults notified about new deposits as soon as these
+        // deposits get swept. Vaults not trusted by the Bridge can still be
+        // used by Bank balance owners on their own responsibility - anyone can
+        // approve their Bank balance to any address.
+        mapping(address => bool) isVaultTrusted;
+        // Collection of all moved funds sweep requests indexed by
+        // `keccak256(movingFundsTxHash | movingFundsOutputIndex)`.
+        // The `movingFundsTxHash` is `bytes32` (ordered as in Bitcoin
+        // internally) and `movingFundsOutputIndex` an `uint32`. Each entry
+        // is actually an UTXO representing the moved funds and is supposed
+        // to be swept with the current main UTXO of the recipient wallet.
+        mapping(uint256 => MovingFunds.MovedFundsSweepRequest) movedFundsSweepRequests;
+        // Collection of all pending redemption requests indexed by
+        // redemption key built as
+        // `keccak256(walletPubKeyHash | redeemerOutputScript)`.
+        // The `walletPubKeyHash` is the 20-byte wallet's public key hash
+        // (computed using Bitcoin HASH160 over the compressed ECDSA
+        // public key) and `redeemerOutputScript` is a Bitcoin script
+        // (P2PKH, P2WPKH, P2SH or P2WSH) that will be used to lock
+        // redeemed BTC as requested by the redeemer. Requests are added
+        // to this mapping by the `requestRedemption` method (duplicates
+        // not allowed) and are removed by one of the following methods:
+        // - `submitRedemptionProof` in case the request was handled
+        //    successfully,
+        // - `notifyRedemptionTimeout` in case the request was reported
+        //    to be timed out.
+        mapping(uint256 => Redemption.RedemptionRequest) pendingRedemptions;
+        // Collection of all timed out redemptions requests indexed by
+        // redemption key built as
+        // `keccak256(walletPubKeyHash | redeemerOutputScript)`. The
+        // `walletPubKeyHash` is the 20-byte wallet's public key hash
+        // (computed using Bitcoin HASH160 over the compressed ECDSA
+        // public key) and `redeemerOutputScript` is the Bitcoin script
+        // (P2PKH, P2WPKH, P2SH or P2WSH) that is involved in the timed
+        // out request. Timed out requests are stored in this mapping to
+        // avoid slashing the wallets multiple times for the same timeout.
+        // Only one method can add to this mapping:
+        // - `notifyRedemptionTimeout` which puts the redemption key to this
+        //    mapping basing on a timed out request stored previously in
+        //    `pendingRedemptions` mapping.
+        mapping(uint256 => Redemption.RedemptionRequest) timedOutRedemptions;
+        // Collection of all submitted fraud challenges indexed by challenge
+        // key built as `keccak256(walletPublicKey|sighash)`.
+        mapping(uint256 => Fraud.FraudChallenge) fraudChallenges;
+        // Collection of main UTXOs that are honestly spent indexed by
+        // `keccak256(fundingTxHash | fundingOutputIndex)`. The `fundingTxHash`
+        // is `bytes32` (ordered as in Bitcoin internally) and
+        // `fundingOutputIndex` an `uint32`. A main UTXO is considered honestly
+        // spent if it was used as an input of a transaction that have been
+        // proven in the Bridge.
+        mapping(uint256 => bool) spentMainUTXOs;
         // Maps the 20-byte wallet public key hash (computed using Bitcoin
         // HASH160 over the compressed ECDSA public key) to the basic wallet
         // information like state and pending redemptions value.
@@ -425,9 +433,9 @@ library BridgeState {
         uint64 _redemptionDustThreshold,
         uint64 _redemptionTreasuryFeeDivisor,
         uint64 _redemptionTxMaxFee,
-        uint256 _redemptionTimeout,
+        uint64 _redemptionTimeout,
         uint96 _redemptionTimeoutSlashingAmount,
-        uint256 _redemptionTimeoutNotifierRewardMultiplier
+        uint64 _redemptionTimeoutNotifierRewardMultiplier
     ) internal {
         require(
             _redemptionDustThreshold > self.movingFundsDustThreshold,
@@ -546,7 +554,7 @@ library BridgeState {
         uint64 _movedFundsSweepTxMaxTotalFee,
         uint32 _movedFundsSweepTimeout,
         uint96 _movedFundsSweepTimeoutSlashingAmount,
-        uint256 _movedFundsSweepTimeoutNotifierRewardMultiplier
+        uint64 _movedFundsSweepTimeoutNotifierRewardMultiplier
     ) internal {
         require(
             _movingFundsTxMaxTotalFee > 0,
@@ -709,10 +717,10 @@ library BridgeState {
     ///      - Fraud notifier reward multiplier must be in the range [0, 100].
     function updateFraudParameters(
         Storage storage self,
-        uint256 _fraudChallengeDepositAmount,
-        uint256 _fraudChallengeDefeatTimeout,
+        uint96 _fraudChallengeDepositAmount,
+        uint32 _fraudChallengeDefeatTimeout,
         uint96 _fraudSlashingAmount,
-        uint256 _fraudNotifierRewardMultiplier
+        uint32 _fraudNotifierRewardMultiplier
     ) internal {
         require(
             _fraudChallengeDefeatTimeout > 0,

package/contracts/bridge/DepositSweep.sol

@@ -149,6 +149,9 @@ library DepositSweep {
         BitcoinTx.UTXO calldata mainUtxo,
         address vault
     ) external {
+        // Wallet state validation is performed in the
+        // `resolveDepositSweepingWallet` function.
+
         // 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

package/contracts/bridge/Fraud.sol

@@ -384,6 +384,8 @@ library Fraud {
         uint32[] calldata walletMembersIDs,
         bytes memory preimageSha256
     ) external {
+        // Wallet state is validated in `notifyWalletFraudChallengeDefeatTimeout`.
+
         bytes32 sighash = sha256(preimageSha256);
 
         uint256 challengeKey = uint256(
@@ -421,38 +423,11 @@ library Fraud {
         );
         bytes20 walletPubKeyHash = compressedWalletPublicKey.hash160View();
 
-        Wallets.Wallet storage wallet = self.registeredWallets[
-            walletPubKeyHash
-        ];
-
-        Wallets.WalletState walletState = wallet.state;
-
-        if (
-            walletState == Wallets.WalletState.Live ||
-            walletState == Wallets.WalletState.MovingFunds ||
-            walletState == Wallets.WalletState.Closing
-        ) {
-            self.ecdsaWalletRegistry.seize(
-                self.fraudSlashingAmount,
-                self.fraudNotifierRewardMultiplier,
-                challenge.challenger,
-                wallet.ecdsaWalletID,
-                walletMembersIDs
-            );
-
-            self.terminateWallet(walletPubKeyHash);
-        } else if (walletState == Wallets.WalletState.Terminated) {
-            // This is a special case when the wallet was already terminated
-            // due to a previous deliberate protocol violation. In that
-            // case, this function should be still callable for other fraud
-            // challenges timeouts in order to let the challenger unlock its
-            // ETH deposit back. However, the wallet termination logic is
-            // not called and the challenger is not rewarded.
-        } else {
-            revert(
-                "Wallet must be in Live or MovingFunds or Closing or Terminated state"
-            );
-        }
+        self.notifyWalletFraudChallengeDefeatTimeout(
+            walletPubKeyHash,
+            walletMembersIDs,
+            challenge.challenger
+        );
 
         // slither-disable-next-line reentrancy-events
         emit FraudChallengeDefeatTimedOut(walletPubKeyHash, sighash);

package/contracts/bridge/MovingFunds.sol

@@ -359,6 +359,8 @@ library MovingFunds {
         BitcoinTx.UTXO calldata mainUtxo,
         bytes20 walletPubKeyHash
     ) external {
+        // Wallet state is validated in `notifyWalletFundsMoved`.
+
         // 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
@@ -368,13 +370,31 @@ library MovingFunds {
             movingFundsProof
         );
 
+        // Assert that main UTXO for passed wallet exists in storage.
+        bytes32 mainUtxoHash = self
+            .registeredWallets[walletPubKeyHash]
+            .mainUtxoHash;
+        require(mainUtxoHash != bytes32(0), "No main UTXO for given wallet");
+
+        // Assert that passed main UTXO parameter is the same as in storage and
+        // can be used for further processing.
+        require(
+            keccak256(
+                abi.encodePacked(
+                    mainUtxo.txHash,
+                    mainUtxo.txOutputIndex,
+                    mainUtxo.txOutputValue
+                )
+            ) == mainUtxoHash,
+            "Invalid main UTXO data"
+        );
+
         // Process the moving funds transaction input. Specifically, check if
         // it refers to the expected wallet's main UTXO.
         OutboundTx.processWalletOutboundTxInput(
             self,
             movingFundsTx.inputVector,
-            mainUtxo,
-            walletPubKeyHash
+            mainUtxo
         );
 
         (
@@ -548,31 +568,19 @@ library MovingFunds {
         bytes20 walletPubKeyHash,
         uint32[] calldata walletMembersIDs
     ) external {
-        Wallets.Wallet storage wallet = self.registeredWallets[
-            walletPubKeyHash
-        ];
+        // Wallet state is validated in `notifyWalletMovingFundsTimeout`.
 
-        require(
-            wallet.state == Wallets.WalletState.MovingFunds,
-            "Wallet must be in MovingFunds state"
-        );
+        uint32 movingFundsRequestedAt = self
+            .registeredWallets[walletPubKeyHash]
+            .movingFundsRequestedAt;
 
         require(
             /* solhint-disable-next-line not-rely-on-time */
-            block.timestamp >
-                wallet.movingFundsRequestedAt + self.movingFundsTimeout,
+            block.timestamp > movingFundsRequestedAt + self.movingFundsTimeout,
             "Moving funds has not timed out yet"
         );
 
-        self.ecdsaWalletRegistry.seize(
-            self.movingFundsTimeoutSlashingAmount,
-            self.movingFundsTimeoutNotifierRewardMultiplier,
-            msg.sender,
-            wallet.ecdsaWalletID,
-            walletMembersIDs
-        );
-
-        self.terminateWallet(walletPubKeyHash);
+        self.notifyWalletMovingFundsTimeout(walletPubKeyHash, walletMembersIDs);
 
         // slither-disable-next-line reentrancy-events
         emit MovingFundsTimedOut(walletPubKeyHash);
@@ -596,14 +604,7 @@ library MovingFunds {
         bytes20 walletPubKeyHash,
         BitcoinTx.UTXO calldata mainUtxo
     ) external {
-        Wallets.Wallet storage wallet = self.registeredWallets[
-            walletPubKeyHash
-        ];
-
-        require(
-            wallet.state == Wallets.WalletState.MovingFunds,
-            "Wallet must be in MovingFunds state"
-        );
+        // Wallet state is validated in `notifyWalletMovingFundsBelowDust`.
 
         uint64 walletBtcBalance = self.getWalletBtcBalance(
             walletPubKeyHash,
@@ -615,7 +616,7 @@ library MovingFunds {
             "Wallet BTC balance must be below the moving funds dust threshold"
         );
 
-        self.beginWalletClosing(walletPubKeyHash);
+        self.notifyWalletMovingFundsBelowDust(walletPubKeyHash);
 
         // slither-disable-next-line reentrancy-events
         emit MovingFundsBelowDustReported(walletPubKeyHash);
@@ -666,6 +667,9 @@ library MovingFunds {
         BitcoinTx.Proof calldata sweepProof,
         BitcoinTx.UTXO calldata mainUtxo
     ) external {
+        // Wallet state validation is performed in the
+        // `resolveMovedFundsSweepingWallet` function.
+
         // 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
@@ -1024,6 +1028,8 @@ library MovingFunds {
         uint32 movingFundsTxOutputIndex,
         uint32[] calldata walletMembersIDs
     ) external {
+        // Wallet state is validated in `notifyWalletMovedFundsSweepTimeout`.
+
         MovedFundsSweepRequest storage sweepRequest = self
             .movedFundsSweepRequests[
                 uint256(
@@ -1049,36 +1055,18 @@ library MovingFunds {
         );
 
         bytes20 walletPubKeyHash = sweepRequest.walletPubKeyHash;
-        Wallets.Wallet storage wallet = self.registeredWallets[
-            walletPubKeyHash
-        ];
-        Wallets.WalletState walletState = wallet.state;
 
-        require(
-            walletState == Wallets.WalletState.Live ||
-                walletState == Wallets.WalletState.MovingFunds ||
-                walletState == Wallets.WalletState.Terminated,
-            "Wallet must be in Live or MovingFunds or Terminated state"
+        self.notifyWalletMovedFundsSweepTimeout(
+            walletPubKeyHash,
+            walletMembersIDs
         );
 
+        Wallets.Wallet storage wallet = self.registeredWallets[
+            walletPubKeyHash
+        ];
         sweepRequest.state = MovedFundsSweepRequestState.TimedOut;
         wallet.pendingMovedFundsSweepRequestsCount--;
 
-        if (
-            walletState == Wallets.WalletState.Live ||
-            walletState == Wallets.WalletState.MovingFunds
-        ) {
-            self.ecdsaWalletRegistry.seize(
-                self.movedFundsSweepTimeoutSlashingAmount,
-                self.movedFundsSweepTimeoutNotifierRewardMultiplier,
-                msg.sender,
-                wallet.ecdsaWalletID,
-                walletMembersIDs
-            );
-
-            self.terminateWallet(walletPubKeyHash);
-        }
-
         // slither-disable-next-line reentrancy-events
         emit MovedFundsSweepTimedOut(
             walletPubKeyHash,