Stellar Contracts - Spiko

During redemption execution, the contract attempts to burn the redeemed tokens from the user’s account (from) even though those tokens were already transferred into the Redemption contract during the initial redeem call.

As a result, execution reverts due to insufficient user balance, leaving the redemption stuck in Pending while tokens remain locked in the Redemption contract. If the user later holds funds, this could double-charge the user while keeping escrowed funds locked, causing supply/accounting inconsistencies.

Code Location

Code of execute_redemptions function from contracts/redemption/src/contract.rs file:

pub fn execute_redemptions(
    e: &Env,
    caller: Address,
    operations: Vec<ExecuteRedemptionOperation>,
) {
    caller.require_auth();
    Self::assert_has_role(e, &caller, &REDEMPTION_EXECUTOR_ROLE);
    let redemption_contract_address = e.current_contract_address();

    for operation in &operations {
        let token = operation.0;
        let from = operation.1;
        let amount = operation.2;
        let salt = operation.3;

        Self::assert_token_registered(e, &token);

        let redemption_hash = Self::compute_redemption_hash(e, &token, &from, amount, &salt);
        Self::assert_redemption_status(e, &redemption_hash, RedemptionStatus::Pending);

        let client: TokenClient<'_> = TokenClient::new(e, &token);

        client.burn(&from, &amount, &redemption_contract_address);

        Self::set_redemption_status(e, &redemption_hash, RedemptionStatus::Executed);
        e.events().publish(
            (REDEMPTION_EVENT, REDEMPTION_EXECUTED_EVENT),
            RedemptionEntry(token, from, amount, salt),
        );
    }
}

Scenario

• A whitelisted user redeems a positive token amount. The Token contract transfers that amount from the user to the Redemption contract (escrow) and records the entry as Pending via Redemption.on_redeem.

• An authorized executor later calls Redemption.execute_redemptions for that same entry.

• The Redemption contract attempts to burn the redeemed amount from the user’s address instead of from the Redemption contract (where the tokens actually reside after redeem).

Test Code

use token::contract::{Token, TokenClient};

fn deploy_real_token(e: &Env) -> (Address, Address, TokenClient<'_>) {
    let owner: Address = Address::generate(e);
    let name: String = String::from_str(e, "Token");
    let symbol: String = String::from_str(e, "EUTBL");
    let decimals: u32 = 6;
    let token_address = e.register(Token, (owner.clone(), name, symbol, decimals));
    let client = TokenClient::new(e, &token_address);
    (owner, token_address, client)
}

#[test]
fn poc_execute_redemptions_fails_with_real_token() {
    let e = setup_env();

    // Deploy Redemption and PermissionManager
    let (_owner_r, redemption_address, redemption_client) = deploy_redemption(&e);
    let (admin, permission_manager_address, permission_manager_client) =
        deploy_permission_manager(&e);
    redemption_client.set_permission_manager(&permission_manager_address);

    // Deploy real token
    let (_owner_t, token_address, token_client) = deploy_real_token(&e);
    token_client.set_permission_manager(&permission_manager_address);
    token_client.set_redemption(&redemption_address);

    // Roles
    let user: Address = Address::generate(&e);
    let executor: Address = Address::generate(&e);

    // Whitelist user and Redemption (current design requires it)
    permission_manager_client.grant_role(&admin, &user, &WHITELISTED_ROLE);
    permission_manager_client.grant_role(&admin, &redemption_address, &WHITELISTED_ROLE);

    // Allow minting and burning
    let minter: Address = Address::generate(&e);
    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
    permission_manager_client.grant_role(&admin, &redemption_address, &BURNER_ROLE);

    // Register token on Redemption
    redemption_client.add_token(&token_address);

    // Mint to user and redeem (moves funds into Redemption)
    let amount: i128 = 1000;
    let salt: String = String::from_str(&e, "SALT");
    token_client.mint(&user, &amount, &minter);
    token_client.redeem(&amount, &user, &salt);

    // Sanity check
    assert_eq!(token_client.balance(&user), 0);
    assert_eq!(token_client.balance(&redemption_address), amount);

    // Execute redemptions → should revert due to burning from user instead of Redemption
    let mut ops = Vec::new(&e);
    ops.push_front(ExecuteRedemptionOperation(
        token_address.clone(),
        user.clone(),
        amount,
        salt.clone(),
    ));

    permission_manager_client.grant_role(&admin, &executor, &REDEMPTION_EXECUTOR_ROLE);
    let res = redemption_client.try_execute_redemptions(&executor, &ops);
    assert!(res.is_err());

    // Funds remain locked in Redemption
    assert_eq!(token_client.balance(&redemption_address), amount);
}

Result

• Mint succeeded; redeem moved the funds to the Redemption contract (user balance = 0, Redemption balance = amount).

• Calling execute_redemptions returned an error (revert) because the burn targeted the user (insufficient balance).

• Funds remained locked in the Redemption contract (Redemption balance unchanged), and the redemption status did not progress, demonstrating a DoS/lock on the redemption flow.

Burning of tokens should be performed from the Redemption contract's own balance (burn(account = Redemption, caller = Redemption)) rather than from the user's account.

SOLVED: The Spiko team has solved this issue by replacing the user's address with the contract address.