## Description When `initiateUnstaking()` is called on the Staking contract, the assumption is that the SXT-chain processing will not fail. If for any reason the `process_unstake_initiated()` function returns an error for the row in which the respective unstake event sits, `process_unstake_initiated()` will simply emit an error with a `deposit_event`, not return it: ```rust pub fn process_unstake_initiated(request: SystemRequest) -> DispatchResult { request .rows() .map(|row| -> DispatchResult { match row.get("STAKER") { Some(SystemFieldValue::Bytes(staker)) => { let staker = hex::encode(staker); let staker_id = sxt_core::utils::eth_address_to_substrate_account_id::(&staker)?; let staker_signer: OriginFor = RawOrigin::Signed(staker_id.clone()).into(); let raw_balance: u128 = pallet_balances::Pallet::::free_balance(staker_id) .unique_saturated_into(); let staking_balance: T::CurrencyBalance = T::CurrencyBalance::from( UniqueSaturatedInto::::unique_saturated_into(raw_balance), ); pallet_staking::Pallet::::unbond(staker_signer, staking_balance) .map_err(|e| e.error)?; Ok(()) } _ => Err(Error::::MissingExpectedField.into()), } }) @> .for_each(emit_for_error::); Ok(()) } ``` One of the scenarios in which this could happen is when the `unlocking` limit is reached on the staking ledger: ```rust ensure!( ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize, Error::::NoMoreChunks, ); ``` Note that `MaxUnlockingChunks` is `32` ( `sxt-node/runtime/src/lib.rs` ): ```rust type MaxUnlockingChunks = frame_support::traits::ConstU32<32>; ``` Under normal circumstances the staker would simply call `cancelInitiateUnstake()` and try again in the future. If they call `claimUnstake()` without realizing that the initialization failed, the stake will be permanently stuck in the StakingPool. It is also possible that unstake initialization did succeed and the user calls `claimUnstake()` after waiting for the `UNSTAKING_UNBONDING_PERIOD` to pass: ```solidity // @inheritdoc IStaking function claimUnstake() external requireState(msg.sender, StakerState.UnstakeInitiated) whenNotPaused { uint64 earliestPossibleClaimUnstakeRequest = initiateUnstakeRequestsTimestamp[msg.sender] + UNSTAKING_UNBONDING_PERIOD; // slither-disable-next-line timestamp if (block.timestamp < earliestPossibleClaimUnstakeRequest) revert UnstakeNotUnbonded(); ``` If the `sxtFulfillUnstake()` then reverts due to insufficient valid signatures, the user **cannot** recover and their stake is also permanently stuck. ## Recommendation Consider adding some sort of safety mechanism that allows a permissioned actor saving the user from such scenario and unlocking their stake by changing their StakerState back to Staked.

Bounty	Date	Submissions	Payout
Private	Nov 18, 2025	1	$0
Private	Nov 5, 2025	1	$0

bbl4de

Public reviews