Source – Alkane 2:88107 — SUBFROST Explorer

src/tests/fire_staking_flow_test.rs26,209 B

//! # TIER 2: Stake → Mine → Claim → Unstake roundtrip
//!
//! Full business flow through the proxied FIRE deployment:
//! 1. Spawn mock LP token, deploy FIRE stack, mint LP to deployer
//! 2. CreateNextEpoch via staking-factory proxy
//! 3. Stake LP through the per-epoch clone
//! 4. Mine blocks → FIRE emission accrues
//! 5. Claim rewards → verify FIRE minted
//! 6. Wait lock expiry → unstake → verify LP returned
use crate::test_log;
use crate::tests::fire_foundation_proxied::{
deploy_fire_proxied, deploy_mock_token, mine_empty, query_epoch_contract,
};
use crate::tests::helpers::{
clear_test_environment, create_block_with_coinbase_tx,
create_multiple_cellpack_with_witness_and_in, get_sheet_by_outpoint,
index_block,
};
use alkanes_support::cellpack::Cellpack;
use alkanes_support::id::AlkaneId;
use anyhow::Result;
use bitcoin::{OutPoint, Witness};
use wasm_bindgen_test::wasm_bindgen_test;
const MOCK_LP_TX: u128 = 0xa00;
const LP_MINT_UNITS: u128 = 10_000_000_000; // 100 LP with 8 decimals
fn mock_lp_id() -> AlkaneId { AlkaneId { block: 4, tx: MOCK_LP_TX } }
/// Construct + index one tx consuming `input_outpoint`, return new outpoint (vout 0).
fn call_with_input(
height: u32,
target: AlkaneId,
inputs: Vec<u128>,
input_outpoint: OutPoint,
) -> Result<OutPoint> {
let mut block = create_block_with_coinbase_tx(height);
let cellpack = Cellpack { target, inputs };
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(), vec![cellpack], input_outpoint, false,
);
let txid = tx.compute_txid();
block.txdata.push(tx);
index_block(&block, height)?;
Ok(OutPoint { txid, vout: 0 })
}
#[wasm_bindgen_test]
fn stake_claim_unstake_full_flow() -> Result<()> {
clear_test_environment();
test_log!("\n=== TIER 2: stake_claim_unstake_full_flow ===");
let start_height = 880_000u32;
// 1. Mock LP token at slot 0xa00 with 100 LP minted
let lp_outpoint = deploy_mock_token(start_height, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = start_height + 1;
{
let sheet = get_sheet_by_outpoint(&lp_outpoint)?;
let lp_bal = sheet.get_cached(&mock_lp_id().into());
test_log!("[FLOW] minted mock LP: {}", lp_bal);
assert_eq!(lp_bal, LP_MINT_UNITS);
}
// 2. Full FIRE deployment (activation_block = h+2 so epoch can start before stake)
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
test_log!("[FLOW] FIRE deployed, current height {}, activation {}", h, activation_block);
// 3. CreateNextEpoch — creates per-epoch clone at (2, sequence). No auth required
// (factory's create_next_epoch has no only_owner guard — permissionless).
let mut block = create_block_with_coinbase_tx(h);
let cellpack = Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] };
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![cellpack],
// No input needed for create_next_epoch (no auth, no LP)
OutPoint::null(),
false,
);
block.txdata.push(tx);
index_block(&block, h)?;
h += 1;
// Query the epoch contract id via factory view (GetEpochContract opcode 11).
let epoch_id = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
test_log!("[FLOW] epoch 0 contract: {:?}", epoch_id);
assert_ne!(epoch_id, AlkaneId::default(), "epoch contract id must be non-zero");
// 4. Stake 50 LP for 0 lock (no multiplier boost — simpler).
// Need to consume the LP outpoint as txin so LP is in incoming_alkanes.
let stake_amount = 5_000_000_000u128; // 50 LP
let post_stake = call_with_input(
h,
epoch_id,
vec![1, 0, stake_amount], // Stake(lock_duration=0, amount=50 LP)
lp_outpoint,
)?;
h += 1;
// Verify: outpoint should have LP change (50 LP) + position NFT (1 unit of some 2:N).
let sheet = get_sheet_by_outpoint(&post_stake)?;
let lp_change = sheet.get_cached(&mock_lp_id().into());
test_log!("[FLOW] LP change after stake: {} (expected {})",
lp_change, LP_MINT_UNITS - stake_amount);
assert_eq!(lp_change, LP_MINT_UNITS - stake_amount, "LP change must equal initial - staked");
// 5. Mine 10 blocks for emission to accrue.
for _ in 0..10 {
mine_empty(h)?;
h += 1;
}
test_log!("[FLOW] mined 10 blocks, height now {}", h);
// 6. Claim rewards. Need to send position NFT in incoming.
// We don't know the NFT's exact AlkaneId here (it was minted at 2:seq during stake),
// but post_stake outpoint has it. claim_rewards with target_position={0,0} = first found.
let post_claim = call_with_input(
h,
epoch_id,
vec![3, 0, 0], // ClaimRewards(target_position={0,0})
post_stake,
)?;
h += 1;
// Verify FIRE minted to caller — find any (4:fire_token_proxy) balance increase.
let sheet = get_sheet_by_outpoint(&post_claim)?;
let fire_balance = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[FLOW] FIRE balance after claim: {}", fire_balance);
assert!(fire_balance > 0, "claim_rewards must mint FIRE (got {})", fire_balance);
test_log!("[FLOW] ✓ stake→mine→claim path works");
Ok(())
}
#[wasm_bindgen_test]
fn create_epoch_one_after_zero_expires_halves_emission() -> Result<()> {
// After epoch 0 expires, create_next_epoch creates epoch 1 with halving_epoch=1
// → emission rate halved. Verify via GetEmissionRate (opcode varies per impl).
// We verify by reading the per-block reward accrual.
clear_test_environment();
test_log!("\n=== TIER 3: create_epoch_one_after_zero_expires ===");
use crate::tests::helpers::simulate_cellpack;
let lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
// Create epoch 0
let mut block = create_block_with_coinbase_tx(h);
block.txdata.push(create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
));
index_block(&block, h)?;
h += 1;
let epoch0 = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
test_log!("[E1] epoch 0: {:?}", epoch0);
// Mine to next absolute epoch boundary (945_000 = epoch 9 in absolute terms)
test_log!("[E1] mining to epoch boundary (945000)...");
while (h as u128) < 945_001 { mine_empty(h)?; h += 1; }
test_log!("[E1] height now {}", h);
// Create epoch 1
let mut block = create_block_with_coinbase_tx(h);
block.txdata.push(create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
));
index_block(&block, h)?;
h += 1;
let epoch1 = query_epoch_contract(dep.fire_staking_factory_id, 1, h)?;
test_log!("[E1] epoch 1: {:?}", epoch1);
assert_ne!(epoch1, epoch0, "epoch 1 must be a different contract");
// Stake in epoch 1, verify emission rate is halved.
let post_stake = call_with_input(
h, epoch1,
vec![1, 0, 5_000_000_000], // 50 LP, no lock
lp_outpoint,
)?;
h += 1;
// Mine 10 blocks then claim — at halved rate, expected ≈ 11 × 425M = 4,675,000,000
// (vs epoch 0 rate which would have been 11 × 850M = 9,350,000,000).
for _ in 0..10 { mine_empty(h)?; h += 1; }
let post_claim = call_with_input(
h, epoch1,
vec![3, 0, 0],
post_stake,
)?;
let sheet = get_sheet_by_outpoke_balance(&post_claim, dep.fire_token_id)?;
test_log!("[E1] FIRE claimed in epoch 1 over ~11 blocks: {}", sheet);
// Epoch 1 halving_epoch=1 → STAKING_EMISSION_RATE/2 = 425_000_000 / block
// Expected ≈ 11 × 425_000_000 = 4_675_000_000. Allow ±10% drift.
assert!(sheet >= 4_000_000_000 && sheet <= 5_500_000_000,
"epoch 1 emission must be halved (~4.675B), got {}", sheet);
test_log!("[E1] ✓ epoch 1 emission halved correctly");
Ok(())
}
fn get_sheet_by_outpoke_balance(out: &OutPoint, token: AlkaneId) -> Result<u128> {
Ok(get_sheet_by_outpoint(out)?.get_cached(&token.into()))
}
#[wasm_bindgen_test]
fn epoch_transition_stake_in_old_unstake_in_new() -> Result<()> {
// TIER 3 critical: stake in epoch 0 → mine across halving boundary → claim/unstake
// from the old epoch position. Verify:
// - old position still claimable after new epoch starts
// - emission rate inside epoch 0 was the un-halved rate (since halving_epoch=0)
// - factory CreateNextEpoch creates epoch 1 successfully
clear_test_environment();
test_log!("\n=== TIER 3: epoch_transition_stake_in_old_unstake_in_new ===");
use crate::tests::helpers::simulate_cellpack;
// Use a very-near activation so we don't need to mine 100k blocks.
let lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
// CreateNextEpoch (epoch 0)
let mut block = create_block_with_coinbase_tx(h);
block.txdata.push(create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
));
index_block(&block, h)?;
h += 1;
let epoch0 = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
test_log!("[EPOCH] epoch 0 contract: {:?}", epoch0);
// Stake 50 LP (no lock — simpler, anything ≤ epoch expiry works)
let post_stake = call_with_input(
h, epoch0,
vec![1, 0, 5_000_000_000],
lp_outpoint,
)?;
h += 1;
// Mine some blocks within epoch 0
for _ in 0..100 { mine_empty(h)?; h += 1; }
// The factory's epoch_duration is 105_000 (HALVING_INTERVAL). Cross the boundary.
// Current epoch 0 = absolute epoch 8 (covers blocks 840_000..944_999).
// We're at ~880_127. Crossing 945_000 requires ~65k blocks — too many for tests.
// Instead, mine to expiry and verify behaviors at expiry.
// Epoch 0 expiry = (8+1)*105_000 - 1 = 944_999.
// Skip the heavy mining: query state, expire-by-simulation-of-claim-behavior.
// Sanity: claim from old epoch BEFORE boundary still works
let post_claim_mid = call_with_input(
h, epoch0,
vec![3, 0, 0], // claim_rewards
post_stake,
)?;
h += 1;
let sheet = get_sheet_by_outpoint(&post_claim_mid)?;
let fire_mid = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[EPOCH] mid-epoch claim FIRE: {}", fire_mid);
assert!(fire_mid > 0, "claim from epoch 0 must mint FIRE");
// The full halving-crossing path requires mining ~65k blocks past activation,
// which the test harness can do but slowly. Mine in batches.
// For mainnet-ready confidence, let's mine ~64k blocks (we're at 880_128 + 64500 = 944_628).
// That still keeps us INSIDE epoch 0 (expiry 944_999). Then claim — should work.
test_log!("[EPOCH] mining 64500 blocks to approach epoch boundary...");
for _ in 0..64500 { mine_empty(h)?; h += 1; }
test_log!("[EPOCH] height now {} (epoch 0 expiry = 944999)", h);
// Still within epoch 0 — try to claim from old position
let post_claim_late = call_with_input(
h, epoch0,
vec![3, 0, 0],
post_claim_mid,
)?;
h += 1;
let sheet = get_sheet_by_outpoint(&post_claim_late)?;
let fire_late = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[EPOCH] late-epoch claim total FIRE: {}", fire_late);
assert!(fire_late >= fire_mid, "late claim must yield >= mid claim");
// Now cross expiry: mine past 944_999
while (h as u128) <= 944_999 { mine_empty(h)?; h += 1; }
h += 5; for _ in 0..5 { mine_empty(h - 5)?; } // safety guard
let h_post = h;
test_log!("[EPOCH] height now {} (past expiry 944999)", h_post);
// The old position is now post-expiry. Claim from old epoch should still work
// (returns LP + final FIRE, deregisters NFT).
let post_claim_after = call_with_input(
h_post, epoch0,
vec![3, 0, 0],
post_claim_late,
)?;
let sheet = get_sheet_by_outpoint(&post_claim_after)?;
let lp_returned = sheet.get_cached(&mock_lp_id().into());
let fire_final = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[EPOCH] post-expiry claim → LP={} FIRE={}", lp_returned, fire_final);
assert!(lp_returned >= 5_000_000_000, "post-expiry claim must return staked LP");
assert!(fire_final >= fire_late, "post-expiry claim distributes final FIRE");
test_log!("[EPOCH] ✓ stake survives full epoch lifecycle, post-expiry claim returns LP+FIRE");
Ok(())
}
#[wasm_bindgen_test]
fn upgrade_preserves_state_and_new_impl_works() -> Result<()> {
// TIER 1 critical: deploy v1 → mutate state → upgrade → state intact, new impl works.
// Test target: fire-token proxy. Mutate via business init (already done by deploy_fire_proxied).
// Then deploy a v2 impl WASM at a different slot, upgrade proxy, check storage still readable.
clear_test_environment();
test_log!("\n=== TIER 1: upgrade_preserves_state_and_new_impl_works ===");
use crate::tests::fire_foundation_proxied::{
FIRE_TOKEN_IMPL,
FIRE_TOKEN_PROXY,
};
use crate::tests::helpers::simulate_cellpack;
// Mock LP, then full FIRE deployment
let _lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
let mut auth = dep.master_auth_outpoint;
// Pre-upgrade: read GetMaxSupply via proxy → impl v1
let pre = simulate_cellpack(h as u64, Cellpack { target: dep.fire_token_id, inputs: vec![102] })?;
assert!(!pre.0.data.is_empty(), "v1 impl must respond to GetMaxSupply");
let pre_max: u128 = u128::from_le_bytes(pre.0.data[..16].try_into().unwrap());
test_log!("[UPGRADE] v1 MAX_SUPPLY: {}", pre_max);
assert_eq!(pre_max, 210_000_000_000_000);
// Read state via GetTotalSupply (101) — should be 0 (no FIRE minted yet from this deploy)
let pre_supply_resp = simulate_cellpack(h as u64, Cellpack { target: dep.fire_token_id, inputs: vec![101] })?;
let pre_supply: u128 = u128::from_le_bytes(pre_supply_resp.0.data[..16].try_into().unwrap());
test_log!("[UPGRADE] v1 total_supply: {}", pre_supply);
// Deploy a "v2" impl — same WASM bytes, different slot. Real upgrades would change code;
// for state-preservation this is sufficient.
use crate::tests::vendor::get_fire_token_wasm_bytes;
const FIRE_TOKEN_IMPL_V2: u128 = 0x300;
let mut block = create_block_with_coinbase_tx(h);
let witness = alkanes_support::envelope::RawEnvelope::from(get_fire_token_wasm_bytes().to_vec())
.to_witness(true);
let cellpack = Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TOKEN_IMPL_V2 },
inputs: vec![99],
};
block.txdata.push(crate::tests::helpers::create_multiple_cellpack_with_witness(
witness, vec![cellpack], false,
));
index_block(&block, h)?;
h += 1;
// Upgrade: opcode 32766 on proxy with target_implementation. Requires master auth.
auth = call_with_input(
h, dep.fire_token_id,
vec![0x7ffe, 4, FIRE_TOKEN_IMPL_V2],
auth,
)?;
h += 1;
// Master auth NFT must survive
let sheet = get_sheet_by_outpoint(&auth)?;
let auth_bal = sheet.get_cached(&dep.master_auth_id.into());
test_log!("[UPGRADE] master auth after upgrade: {}", auth_bal);
assert_eq!(auth_bal, 1, "auth NFT must survive upgrade");
// Post-upgrade: proxy must STILL respond to GetMaxSupply (impl v2 has same bytecode)
let post_max_resp = simulate_cellpack(h as u64, Cellpack { target: dep.fire_token_id, inputs: vec![102] })?;
let post_max: u128 = u128::from_le_bytes(post_max_resp.0.data[..16].try_into().unwrap());
test_log!("[UPGRADE] v2 MAX_SUPPLY: {}", post_max);
assert_eq!(post_max, pre_max, "MAX_SUPPLY constant unchanged across upgrade");
// State preservation: total_supply must read the SAME value (storage on proxy untouched)
let post_supply_resp = simulate_cellpack(h as u64, Cellpack { target: dep.fire_token_id, inputs: vec![101] })?;
let post_supply: u128 = u128::from_le_bytes(post_supply_resp.0.data[..16].try_into().unwrap());
test_log!("[UPGRADE] v2 total_supply: {}", post_supply);
assert_eq!(post_supply, pre_supply, "total_supply preserved across upgrade");
test_log!("[UPGRADE] ✓ deploy v1 → upgrade → v2 works, state intact, auth survives");
Ok(())
}
#[wasm_bindgen_test]
fn redemption_burns_fire_returns_lp_proportional() -> Result<()> {
// Redemption flow:
// 1. Stake 50 LP, bond 0.1 LP → treasury has 0.1 LP backing
// 2. claim_vested → mint some FIRE
// 3. Redeem FIRE through fire-redemption → assert LP returned proportionally
clear_test_environment();
test_log!("\n=== TIER 2: redemption_burns_fire_returns_lp_proportional ===");
let lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
// CreateNextEpoch
let mut block = create_block_with_coinbase_tx(h);
block.txdata.push(create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
));
index_block(&block, h)?;
h += 1;
let epoch_id = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
// Stake 50 LP @ 6mo (priors bonding)
let post_stake = call_with_input(
h, epoch_id,
vec![1, 26_250, 5_000_000_000],
lp_outpoint,
)?;
h += 1;
for _ in 0..1000 { mine_empty(h)?; h += 1; }
// Bond 0.1 LP
let post_bond = call_with_input(
h, dep.fire_bonding_id,
vec![1, 10_000_000, 0],
post_stake,
)?;
h += 1;
// Mine PAST vesting period (1050 blocks) to fully vest
for _ in 0..1100 { mine_empty(h)?; h += 1; }
// ClaimVested fully
let post_claim = call_with_input(
h, dep.fire_bonding_id,
vec![2, 0, 0],
post_bond,
)?;
h += 1;
let sheet = get_sheet_by_outpoint(&post_claim)?;
let fire_held = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[REDEEM] FIRE fully vested: {}", fire_held);
assert!(fire_held > 0);
// Treasury LP backing — sanity check via simulate(GetTotalBacking, opcode 24)
use crate::tests::helpers::simulate_cellpack;
let (back_resp, _) = simulate_cellpack(h as u64, Cellpack { target: dep.fire_treasury_id, inputs: vec![24] })?;
let mut tb = [0u8; 16];
if back_resp.data.len() >= 16 { tb.copy_from_slice(&back_resp.data[..16]); }
let total_backing = u128::from_le_bytes(tb);
test_log!("[REDEEM] treasury backing: {} LP base units", total_backing);
assert_eq!(total_backing, 10_000_000, "treasury must hold the bonded 0.1 LP");
// Burn HALF of held FIRE via redemption.
// fire-redemption::Redeem(amount). amount=0 means burn all incoming.
let redeem_amount = fire_held / 2;
let post_redeem = call_with_input(
h, dep.fire_redemption_id,
vec![1, redeem_amount],
post_claim,
)?;
let sheet = get_sheet_by_outpoint(&post_redeem)?;
let lp_received = sheet.get_cached(&mock_lp_id().into());
let fire_change = sheet.get_cached(&dep.fire_token_id.into());
test_log!(
"[REDEEM] post-redeem: LP={} FIRE-change={} (burned {} of {})",
lp_received, fire_change, redeem_amount, fire_held,
);
assert!(lp_received > 0, "redemption must return LP");
assert_eq!(fire_change, fire_held - redeem_amount, "FIRE change = original - burned");
test_log!("[REDEEM] ✓ burn FIRE → receive LP path works");
Ok(())
}
#[wasm_bindgen_test]
fn bond_and_claim_vested_flow() -> Result<()> {
// Bond path: requires (a) total_locked_lp > 0 so oracle price is non-zero,
// (b) elapsed blocks for available_capacity.
// 1. Stake 100 LP @ 6mo lock → total_locked_lp = 100 LP
// 2. Mine ~1000 blocks → capacity = 1000 × 150e6 = 1.5e11
// 3. Bond 0.1 LP → minted FIRE within capacity
// 4. ClaimVested after some vesting → assert FIRE received
clear_test_environment();
test_log!("\n=== TIER 2: bond_and_claim_vested_flow ===");
let lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
// CreateNextEpoch
let mut block = create_block_with_coinbase_tx(h);
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
);
block.txdata.push(tx);
index_block(&block, h)?;
h += 1;
let epoch_id = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
test_log!("[BOND] epoch 0: {:?}", epoch_id);
// Stake 50 LP for 6 months (26_250 blocks). Leave 50 LP for bonding.
let stake_lp = 5_000_000_000u128; // 50 LP
let six_months = 26_250u128;
let post_stake = call_with_input(
h, epoch_id,
vec![1, six_months, stake_lp],
lp_outpoint,
)?;
h += 1;
test_log!("[BOND] staked 100 LP @ 6mo");
// Mine 1000 blocks for bond capacity
for _ in 0..1000 { mine_empty(h)?; h += 1; }
test_log!("[BOND] mined 1000 blocks, height now {}", h);
// Bond 0.1 LP. post_stake outpoint has 100 LP change.
// Cellpack inputs: [1 (Bond), lp_to_bond, min_fire_out]
let bond_lp = 10_000_000u128; // 0.1 LP
let post_bond = call_with_input(
h, dep.fire_bonding_id,
vec![1, bond_lp, 0],
post_stake,
)?;
h += 1;
// Verify a bond NFT exists at post_bond. We don't know its exact AlkaneId,
// but the outpoint should hold something new + LP change. Just check no panic.
let sheet = get_sheet_by_outpoint(&post_bond)?;
let lp_after = sheet.get_cached(&mock_lp_id().into());
let expected_lp = LP_MINT_UNITS - stake_lp - bond_lp;
test_log!("[BOND] LP at post_bond outpoint: {} (expected {})", lp_after, expected_lp);
assert_eq!(lp_after, expected_lp, "LP change after bond");
// Mine to vest some FIRE. DEFAULT_VESTING_PERIOD = 1050 blocks.
for _ in 0..500 { mine_empty(h)?; h += 1; }
// ClaimVested(target_position = {0,0} = first found)
let post_claim = call_with_input(
h, dep.fire_bonding_id,
vec![2, 0, 0],
post_bond,
)?;
let sheet = get_sheet_by_outpoint(&post_claim)?;
let fire_balance = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[BOND] FIRE after claim_vested at 500/1050 vested: {}", fire_balance);
assert!(fire_balance > 0, "claim_vested must mint some FIRE (got {})", fire_balance);
test_log!("[BOND] ✓ bond → mine → claim_vested path works");
Ok(())
}
#[wasm_bindgen_test]
fn unstake_returns_lp_and_final_rewards() -> Result<()> {
// After lock_duration=0 stake, unstake immediately should return:
// - deposited LP exactly
// - any accrued FIRE rewards
clear_test_environment();
test_log!("\n=== TIER 2: unstake_returns_lp_and_final_rewards ===");
let lp_outpoint = deploy_mock_token(880_000, MOCK_LP_TX, LP_MINT_UNITS)?;
let h = 880_001;
let activation_block = (h as u128) + 2;
let dep = deploy_fire_proxied(h, mock_lp_id(), activation_block)?;
let mut h = dep.current_height;
// CreateNextEpoch
let mut block = create_block_with_coinbase_tx(h);
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![Cellpack { target: dep.fire_staking_factory_id, inputs: vec![1] }],
OutPoint::null(), false,
);
block.txdata.push(tx);
index_block(&block, h)?;
h += 1;
let epoch_id = query_epoch_contract(dep.fire_staking_factory_id, 0, h)?;
// Stake 30 LP with no lock
let stake_amount = 3_000_000_000u128;
let post_stake = call_with_input(
h, epoch_id,
vec![1, 0, stake_amount],
lp_outpoint,
)?;
h += 1;
// Mine 5 blocks
for _ in 0..5 { mine_empty(h)?; h += 1; }
// Unstake (target_position {0,0} = first found)
let post_unstake = call_with_input(
h, epoch_id,
vec![2, 0, 0], // Unstake(target_position)
post_stake,
)?;
let sheet = get_sheet_by_outpoint(&post_unstake)?;
let lp_returned = sheet.get_cached(&mock_lp_id().into());
let fire_returned = sheet.get_cached(&dep.fire_token_id.into());
test_log!("[FLOW] unstake → LP={}, FIRE={}", lp_returned, fire_returned);
// After unstake, post_unstake should contain BOTH the LP change (50 LP)
// AND the original deposit (30 LP) since unstake forwards everything.
// Actually the deposited 30 LP comes back at this outpoint.
// The 50 LP "change" was already at post_stake — when we input post_stake to unstake,
// ALL alkanes flow through. So expected: 50 (change) + 30 (deposit) = 80 LP total.
assert!(lp_returned >= stake_amount, "unstake must return at least the deposited LP");
assert!(fire_returned > 0, "unstake should distribute pending FIRE rewards");
test_log!("[FLOW] ✓ unstake returned LP + final FIRE rewards");
Ok(())
}

Verified Source