Source – Alkane 2:85025 — SUBFROST Explorer

crates/fire-support/src/lib.rs104,321 B

//! FIRE Support - Shared utilities for the FIRE token system
pub use fire_constants::*;
/// Calculate lock multiplier based on lock duration in blocks
/// Returns multiplier in basis points where 100 = 1.0x
pub fn get_lock_multiplier(duration_blocks: u64) -> u128 {
if duration_blocks >= YEAR {
MULTIPLIER_YEAR
} else if duration_blocks >= SIX_MONTHS {
MULTIPLIER_SIX_MONTHS
} else if duration_blocks >= THREE_MONTHS {
MULTIPLIER_THREE_MONTHS
} else if duration_blocks >= MONTH {
MULTIPLIER_MONTH
} else if duration_blocks >= WEEK {
MULTIPLIER_WEEK
} else {
MULTIPLIER_BASE // 1.0x for no lock or < 1 week
}
}
/// Calculate emission rate for a given epoch (halving every TWO_YEARS blocks)
/// Epoch 0 = initial rate, Epoch 1 = half, Epoch 2 = quarter, etc.
/// base_rate: starting rate per block (STAKING_EMISSION_RATE or BONDING_EMISSION_RATE)
pub fn get_emission_rate_for_epoch(base_rate: u128, epoch: u128) -> u128 {
if epoch >= 64 {
return 0;
}
base_rate >> epoch
}
/// Calculate absolute epoch from block height.
/// Epoch boundaries at multiples of HALVING_INTERVAL (105,000 blocks).
/// Every 2nd boundary (210,000) coincides with Bitcoin halving.
pub fn absolute_epoch(height: u64) -> u128 {
(height / HALVING_INTERVAL) as u128
}
/// Calculate how many halvings since contract start.
/// Uses absolute epoch boundaries — not relative to start_height.
pub fn calculate_epoch(start_height: u64, current_height: u64) -> u128 {
let start_epoch = absolute_epoch(start_height);
let current_epoch = absolute_epoch(current_height);
(current_epoch.saturating_sub(start_epoch)) as u128
}
// ═══════════════════════════════════════════════════════════════
// Tiny Bonds pricing math (used by fire-price-oracle)
// ═══════════════════════════════════════════════════════════════
/// Exponential decay with floor (tiny-bonds expToLevel).
///
/// 1. Halve x for each full half_life elapsed
/// 2. Linear interpolation for partial period
/// 3. Add floor so result never drops below level_bips% of x
///
/// Used by fire-price-oracle to decay virtual input reserves over time,
/// making FIRE cheaper when nobody is bonding.
pub fn exp_to_level(x: u128, elapsed: u128, half_life: u128, level_bips: u128) -> u128 {
if half_life == 0 || x == 0 {
return x;
}
let shifts = elapsed / half_life;
let mut z = if shifts >= 128 { 0 } else { x >> shifts };
let remainder = elapsed % half_life;
if remainder > 0 && z > 0 {
z -= (z * remainder) / (half_life * 2);
}
if level_bips > 0 && x > z {
z += ((x - z) * level_bips) / 10000;
}
z
}
/// Virtual constant-product AMM output calculation.
/// output = input × virtual_output / (effective_input + input)
pub fn bond_amount_out(input: u128, virtual_output: u128, effective_input: u128) -> u128 {
if effective_input + input == 0 {
return 0;
}
(input * virtual_output) / (effective_input + input)
}
// ═══════════════════════════════════════════════════════════════
// Bond pricing with floor guard
// ═══════════════════════════════════════════════════════════════
/// Calculate effective bond price with floor protection.
///
/// bond_price = max(oracle_price × (1 - discount), floor_price × (1 + premium))
///
/// Returns effective price in LP per FIRE (scaled by DECIMAL_FACTOR).
/// Higher price = fewer FIRE per LP = safer for treasury.
pub fn bond_effective_price(
oracle_price: u128,
floor_price: u128,
discount_bps: u128,
premium_bps: u128,
) -> u128 {
let oracle_discounted = if oracle_price > 0 {
(oracle_price * (10000 - discount_bps)) / 10000
} else {
0
};
let floor_with_premium = (floor_price * (10000 + premium_bps)) / 10000;
if oracle_discounted > floor_with_premium {
oracle_discounted
} else {
floor_with_premium
}
}
/// Calculate FIRE received for LP bonded at effective price.
pub fn bond_fire_amount(lp_amount: u128, effective_price: u128) -> u128 {
if effective_price == 0 {
return 0;
}
(lp_amount * DECIMAL_FACTOR) / effective_price
}
// ═══════════════════════════════════════════════════════════════
// Redemption math
// ═══════════════════════════════════════════════════════════════
/// Calculate redemption rate: LP per FIRE (scaled by DECIMAL_FACTOR)
/// rate = treasury_lp × DECIMAL_FACTOR / total_fire_supply
pub fn redemption_rate(treasury_lp: u128, total_fire_supply: u128) -> u128 {
if total_fire_supply == 0 {
return 0;
}
(treasury_lp * DECIMAL_FACTOR) / total_fire_supply
}
/// Calculate LP returned for redeeming fire_amount
/// value = fire_amount × rate × (10000 - fee_bps) / (DECIMAL_FACTOR × 10000)
pub fn redemption_value(fire_amount: u128, treasury_lp: u128, total_supply: u128, fee_bps: u128) -> u128 {
let rate = redemption_rate(treasury_lp, total_supply);
let value_before_fee = (fire_amount * rate) / DECIMAL_FACTOR;
(value_before_fee * (10000 - fee_bps)) / 10000
}
/// Bond price: LP units per 1 FIRE (scaled by DECIMAL_FACTOR).
/// price = effective_input × DECIMAL_FACTOR / virtual_output
pub fn bond_price(virtual_output: u128, effective_input: u128) -> u128 {
if virtual_output == 0 {
return 0;
}
(effective_input * DECIMAL_FACTOR) / virtual_output
}
#[cfg(test)]
#[allow(deprecated)] // historical proxy slot constants used in invariant assertions
mod tests {
use super::*;
// ── Proxy architecture constants ─────────────────────────────
#[test]
fn test_proxy_ids_dont_collide_with_public_ids() {
// Impl IDs (0x200+) must not overlap with public proxy IDs (0x100+)
assert!(FIRE_TOKEN_IMPL > FIRE_REDEMPTION);
assert!(FIRE_STAKING_FACTORY_IMPL > FIRE_REDEMPTION);
// Beacon IDs must not overlap with impl IDs
assert!(FIRE_STAKING_BEACON > FIRE_STAKING_IMPL);
assert!(FIRE_STAKING_BPROXY > FIRE_STAKING_BEACON);
}
#[test]
fn test_proxy_impl_mapping() {
// Each public ID has a corresponding impl ID offset by 0x100
assert_eq!(FIRE_TOKEN_IMPL, FIRE_TOKEN + 0x100);
assert_eq!(FIRE_STAKING_FACTORY_IMPL, FIRE_STAKING + 0x100);
assert_eq!(FIRE_TREASURY_IMPL, FIRE_TREASURY + 0x100);
assert_eq!(FIRE_BONDING_IMPL, FIRE_BONDING + 0x100);
assert_eq!(FIRE_REDEMPTION_IMPL, FIRE_REDEMPTION + 0x100);
}
#[test]
fn test_proxy_opcodes() {
assert_eq!(PROXY_OPCODE_INITIALIZE, 0x7FFF);
assert_eq!(PROXY_OPCODE_UPGRADE, 0x7FFE);
assert_eq!(PROXY_OPCODE_FORWARD, 0x8FFF);
assert_eq!(BEACON_OPCODE_IMPLEMENTATION, 0x7FFD);
}
#[test]
fn test_beacon_proxy_clone_opcode() {
// Beacon proxy template uses forward (0x8FFF) for CREATECHILD, not GetName (99).
// GetName would hit fallback → delegatecall to unset beacon → revert.
assert_ne!(PROXY_OPCODE_FORWARD, 99);
// Forward opcode must be in the high range (not clash with FIRE opcodes 0-99)
assert!(PROXY_OPCODE_FORWARD > 1000);
}
#[test]
fn test_supply_constants() {
assert_eq!(
STAKING_EMISSION_POOL + BONDING_EMISSION_POOL,
MAX_SUPPLY
);
}
#[test]
fn test_lock_multipliers() {
assert_eq!(get_lock_multiplier(0), 100);
assert_eq!(get_lock_multiplier(WEEK - 1), 100);
assert_eq!(get_lock_multiplier(WEEK), 125);
assert_eq!(get_lock_multiplier(MONTH), 150);
assert_eq!(get_lock_multiplier(THREE_MONTHS), 200);
assert_eq!(get_lock_multiplier(SIX_MONTHS), 250);
assert_eq!(get_lock_multiplier(YEAR), 300);
assert_eq!(get_lock_multiplier(YEAR + 100), 300);
}
#[test]
fn test_emission_halving() {
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 0), STAKING_EMISSION_RATE);
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 1), STAKING_EMISSION_RATE / 2);
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 2), STAKING_EMISSION_RATE / 4);
assert_eq!(get_emission_rate_for_epoch(BONDING_EMISSION_RATE, 0), BONDING_EMISSION_RATE);
}
#[test]
fn test_emission_convergence_to_max_supply() {
// Verify that total emission over all epochs converges to ~MAX_SUPPLY
// Each epoch = TWO_YEARS blocks, rate halves each epoch
// total_emitted = rate_per_block × TWO_YEARS × sum(1/2^i) = rate × TWO_YEARS × 2
let two_years = TWO_YEARS as u128;
let staking_total = STAKING_EMISSION_RATE * two_years * 2;
let staking_target = STAKING_EMISSION_POOL;
let staking_diff = if staking_total > staking_target {
staking_total - staking_target
} else {
staking_target - staking_total
};
assert!(
staking_diff * 100 / staking_target < 2,
"staking convergence off by >2%: total={} target={}",
staking_total, staking_target
);
let bonding_total = BONDING_EMISSION_RATE * two_years * 2;
let bonding_target = BONDING_EMISSION_POOL;
let bonding_diff = if bonding_total > bonding_target {
bonding_total - bonding_target
} else {
bonding_target - bonding_total
};
assert!(
bonding_diff * 100 / bonding_target < 2,
"bonding convergence off by >2%: total={} target={}",
bonding_total, bonding_target
);
let combined = staking_total + bonding_total;
let max = MAX_SUPPLY;
let combined_diff = if combined > max { combined - max } else { max - combined };
assert!(
combined_diff * 100 / max < 2,
"combined convergence off by >2%: total={} max={}",
combined, max
);
}
#[test]
fn test_85_15_split() {
// Verify pools are 85/15
assert_eq!(STAKING_EMISSION_POOL * 100 / MAX_SUPPLY, 85);
assert_eq!(BONDING_EMISSION_POOL * 100 / MAX_SUPPLY, 15);
}
#[test]
fn test_epoch_calculation() {
// Start at block 80,000 (inside absolute epoch 0: blocks 0-104,999)
let start = 80_000u64;
assert_eq!(calculate_epoch(start, 80_000), 0); // same epoch
assert_eq!(calculate_epoch(start, 104_999), 0); // still epoch 0
assert_eq!(calculate_epoch(start, 105_000), 1); // epoch 1 boundary
assert_eq!(calculate_epoch(start, 210_000), 2); // epoch 2 = Bitcoin halving
assert_eq!(calculate_epoch(start, 315_000), 3);
}
#[test]
fn test_absolute_epoch() {
assert_eq!(absolute_epoch(0), 0);
assert_eq!(absolute_epoch(104_999), 0);
assert_eq!(absolute_epoch(105_000), 1);
assert_eq!(absolute_epoch(209_999), 1);
assert_eq!(absolute_epoch(210_000), 2); // Bitcoin halving = even FIRE epoch
assert_eq!(absolute_epoch(420_000), 4); // 2nd Bitcoin halving = epoch 4
}
#[test]
fn test_epoch_alignment_with_bitcoin() {
// Every Bitcoin halving (210,000 multiple) should be an even FIRE epoch
for btc_halving in [210_000u64, 420_000, 630_000, 840_000, 1_050_000] {
let fire_epoch = absolute_epoch(btc_halving);
assert_eq!(fire_epoch % 2, 0, "Bitcoin halving at {} should be even FIRE epoch", btc_halving);
}
}
// ── Tiny Bonds pricing math ───────────────────────────────────
const DAY: u128 = 86400;
const TEST_WEEK: u128 = 604800;
#[test]
fn test_no_decay_at_zero_elapsed() {
let x = 1_000_000_000_000;
assert_eq!(exp_to_level(x, 0, DAY, 9000), x);
}
#[test]
fn test_half_decay_after_one_half_life() {
let x = 1_000_000_000_000;
assert_eq!(exp_to_level(x, DAY, DAY, 0), x / 2);
}
#[test]
fn test_quarter_decay_after_two_half_lives() {
let x = 1_000_000_000_000;
assert_eq!(exp_to_level(x, 2 * DAY, DAY, 0), x / 4);
}
#[test]
fn test_floor_prevents_full_decay() {
let x = 1_000_000_000_000;
let result = exp_to_level(x, 365 * DAY, DAY, 9000);
let expected_floor = (x * 9000) / 10000;
assert_eq!(result, expected_floor);
}
#[test]
fn test_decay_95_percent_after_one_day_with_floor() {
// 1 day elapsed, 1 day half-life, 90% level
// z = x/2 = 500B, floor_add = 500B * 9000/10000 = 450B
// result = 500B + 450B = 950B = 95%
let x = 1_000_000_000_000;
let result = exp_to_level(x, DAY, DAY, 9000);
assert_eq!(result, (x * 9500) / 10000);
}
#[test]
fn test_decay_92_5_percent_after_two_days_with_floor() {
let x = 1_000_000_000_000;
let result = exp_to_level(x, 2 * DAY, DAY, 9000);
assert_eq!(result, (x * 9250) / 10000);
}
#[test]
fn test_partial_period_decay() {
let x = 1_000_000_000_000;
// Half a day, 1 day half-life, no floor
// shifts=0, z=x, remainder=DAY/2
// z -= z * (DAY/2) / (DAY*2) = z/4
let result = exp_to_level(x, DAY / 2, DAY, 0);
assert_eq!(result, x - (x / 4));
}
#[test]
fn test_exp_to_level_zero_input() {
assert_eq!(exp_to_level(0, DAY, DAY, 9000), 0);
}
#[test]
fn test_exp_to_level_zero_half_life() {
let x = 1_000_000_000_000;
assert_eq!(exp_to_level(x, DAY, 0, 9000), x);
}
#[test]
fn test_bond_amount_out_basic() {
// 1 unit into 1000/1000 → ≈0.999
let output = bond_amount_out(1_00000000, 1000_00000000, 1000_00000000);
// output = 1 * 1000 / 1001 ≈ 0.999
assert!(output > 99800000 && output < 100000000,
"got {}", output);
}
#[test]
fn test_bond_amount_out_slippage() {
// 100 into 1000/1000 → ≈90.9 (not 100)
let output = bond_amount_out(100_00000000, 1000_00000000, 1000_00000000);
assert!(output > 90_00000000 && output < 91_00000000,
"got {}", output);
}
#[test]
fn test_bond_price_one_to_one() {
let price = bond_price(1000_00000000, 1000_00000000);
assert_eq!(price, DECIMAL_FACTOR);
}
#[test]
fn test_bond_price_fire_expensive() {
let price = bond_price(1000_00000000, 2000_00000000);
assert_eq!(price, 2 * DECIMAL_FACTOR);
}
#[test]
fn test_purchase_raises_price() {
let v_output = 1000_00000000u128;
let v_input = 1000_00000000u128;
let price_before = bond_price(v_output, v_input);
let alice_output = bond_amount_out(100_00000000, v_output, v_input);
let new_output = v_output - alice_output;
let new_input = v_input + 100_00000000;
let price_after = bond_price(new_output, new_input);
assert!(price_after > price_before);
}
#[test]
fn test_time_decay_lowers_price() {
let v_output = 1000_00000000u128;
let v_input = 1000_00000000u128;
let price_t0 = bond_price(v_output, v_input);
let decayed = exp_to_level(v_input, DAY, DAY, 9000);
let price_t1 = bond_price(v_output, decayed);
assert!(price_t1 < price_t0);
}
#[test]
fn test_alice_before_bob() {
let mut v_output = 1000_00000000u128;
let mut v_input = 1000_00000000u128;
// Alice bonds 10 LP at t=0
let alice_out = bond_amount_out(10_00000000, v_output, v_input);
v_output -= alice_out;
v_input += 10_00000000;
// Small decay (1.5h of 24h half-life)
v_input = exp_to_level(v_input, 5400, DAY, 9000);
// Bob bonds 10 LP
let bob_out = bond_amount_out(10_00000000, v_output, v_input);
assert!(alice_out > bob_out,
"alice={} bob={}", alice_out, bob_out);
}
#[test]
fn test_two_week_half_life() {
let v_output = 396_900_00000000u128;
let v_input = 396_900_00000000u128;
let half_life = 14 * DAY;
let price_t0 = bond_price(v_output, v_input);
assert_eq!(price_t0, DECIMAL_FACTOR);
let decayed_1w = exp_to_level(v_input, TEST_WEEK, half_life, 9000);
let price_1w = bond_price(v_output, decayed_1w);
assert!(price_1w < price_t0);
let decayed_1y = exp_to_level(v_input, 365 * DAY, half_life, 9000);
let price_floor = bond_price(v_output, decayed_1y);
assert_eq!(price_floor, (DECIMAL_FACTOR * 9000) / 10000);
}
// ── Redemption math ───────────────────────────────────────────
#[test]
fn test_redemption_rate_basic() {
// 100,000 LP in treasury, 1,000,000 FIRE supply
let rate = redemption_rate(100_000_00000000, 1_000_000_00000000);
// 1 FIRE = 0.1 LP → rate = 0.1 × DECIMAL_FACTOR = 10,000,000
assert_eq!(rate, 10_000_000);
}
#[test]
fn test_redemption_rate_equal() {
// 1M LP, 1M FIRE → 1:1
let rate = redemption_rate(1_000_000_00000000, 1_000_000_00000000);
assert_eq!(rate, DECIMAL_FACTOR);
}
#[test]
fn test_redemption_rate_zero_supply() {
assert_eq!(redemption_rate(100_000_00000000, 0), 0);
}
#[test]
fn test_redemption_value_no_fee() {
// 100K LP, 1M FIRE, redeem 10K FIRE, 0% fee
let value = redemption_value(10_000_00000000, 100_000_00000000, 1_000_000_00000000, 0);
// 10K / 1M × 100K = 1K LP
assert_eq!(value, 1_000_00000000);
}
#[test]
fn test_redemption_value_with_fee() {
// Same as above but 1% fee (100 bps)
let value = redemption_value(10_000_00000000, 100_000_00000000, 1_000_000_00000000, 100);
// 1K LP × 99% = 990 LP
assert_eq!(value, 990_00000000);
}
#[test]
fn test_redemption_value_10pct_fee() {
// 10% fee (1000 bps)
let value = redemption_value(10_000_00000000, 100_000_00000000, 1_000_000_00000000, 1000);
// 1K LP × 90% = 900 LP
assert_eq!(value, 900_00000000);
}
#[test]
fn test_redemption_full_supply() {
// Redeem ALL supply → should get ALL treasury LP (minus fee)
let value = redemption_value(1_000_000_00000000, 100_000_00000000, 1_000_000_00000000, 100);
// 100K LP × 99% = 99K LP
assert_eq!(value, 99_000_00000000);
}
#[test]
fn test_redemption_supply_decreases_after_burn() {
// Simulate: treasury has 100K LP, supply is 1M
// User redeems 100K FIRE → burns → supply becomes 900K
// Next user redeems 100K FIRE → gets MORE per FIRE because supply is lower
let treasury_lp = 100_000_00000000u128;
let initial_supply = 1_000_000_00000000u128;
let value1 = redemption_value(100_000_00000000, treasury_lp, initial_supply, 0);
// 100K / 1M × 100K = 10K LP
assert_eq!(value1, 10_000_00000000);
// After burn: supply = 900K, treasury = 100K - 10K = 90K
let new_supply = initial_supply - 100_000_00000000;
let new_treasury = treasury_lp - value1;
let value2 = redemption_value(100_000_00000000, new_treasury, new_supply, 0);
// 100K / 900K × 90K = 10K LP — same amount! (proportional stays constant)
assert_eq!(value2, 10_000_00000000);
}
#[test]
fn test_redemption_partial_vs_full() {
// Redeeming 500 FIRE out of 1000 sent should give half the value
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let full = redemption_value(1000_00000000, treasury_lp, supply, 100);
let half = redemption_value(500_00000000, treasury_lp, supply, 100);
assert_eq!(half * 2, full);
}
// ══════════════════════════════════════════════════════════════
// Attack vector tests
// ══════════════════════════════════════════════════════════════
#[test]
fn test_burn_order_attack_prevented() {
// THE CRITICAL BUG: if burn happens BEFORE treasury query,
// supply is smaller → share is larger → redeemer gets extra LP.
//
// Correct order: treasury calculates with PRE-BURN supply, burn AFTER.
let treasury_lp = 1000_00000000u128;
let supply = 10000_00000000u128;
let redeem = 5000_00000000u128; // 50% of supply
// CORRECT (burn after): share calculated with full supply
let correct_share = redemption_value(redeem, treasury_lp, supply, 0);
assert_eq!(correct_share, 500_00000000, "50% of supply should get 50% of treasury");
// WRONG (burn before): supply decreased before calculation
let wrong_supply = supply - redeem; // supply after burn
let wrong_share = redemption_value(redeem, treasury_lp, wrong_supply, 0);
assert_eq!(wrong_share, 1000_00000000, "burn-first would give 100% of treasury!");
// Verify the exploit magnitude
assert!(wrong_share > correct_share, "burn-first gives more than correct");
assert_eq!(wrong_share, treasury_lp, "burn-first drains entire treasury for 50% redeem");
}
#[test]
fn test_burn_order_small_redeem_difference() {
// Even small redemptions are affected
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let redeem = 10_000_00000000u128; // 1% of supply
let correct = redemption_value(redeem, treasury_lp, supply, 0);
let wrong = redemption_value(redeem, treasury_lp, supply - redeem, 0);
// correct: 1% of 100K = 1K LP
assert_eq!(correct, 1_000_00000000);
// wrong: 10K/990K × 100K = 1010.1 LP (~1% extra)
assert!(wrong > correct);
let extra_bps = ((wrong - correct) * 10000) / correct;
assert!(extra_bps <= 102, "1% redeem should give ~1% extra if burn-first: got {} bps", extra_bps);
}
#[test]
fn test_sequential_redemptions_maintain_ratio() {
// Multiple redemptions should maintain floor_price = treasury/supply
let mut treasury = 100_000_00000000u128;
let mut supply = 1_000_000_00000000u128;
let redeem_each = 100_000_00000000u128; // 10% each time
let initial_ratio = treasury * DECIMAL_FACTOR / supply;
for i in 0..5 {
let value = redemption_value(redeem_each, treasury, supply, 0);
treasury -= value;
supply -= redeem_each;
let new_ratio = treasury * DECIMAL_FACTOR / supply;
assert_eq!(new_ratio, initial_ratio,
"ratio should stay constant after redemption {} (treasury={}, supply={})",
i + 1, treasury / DECIMAL_FACTOR, supply / DECIMAL_FACTOR);
}
}
#[test]
fn test_bond_redeem_cycle_always_unprofitable() {
// Bond LP → get FIRE at discount → redeem FIRE → get LP back
// Must ALWAYS be unprofitable (get less LP than you put in)
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let discount_bps = 1000u128; // 10%
let oracle_price = DECIMAL_FACTOR; // 1:1
let lp_in = 10_000_00000000u128; // Bond 10K LP
// Step 1: Bond — get FIRE with discount
let fire_received = (lp_in * (10000 + discount_bps) * DECIMAL_FACTOR) / (oracle_price * 10000);
// = 10K × 1.1 = 11K FIRE
// Step 2: Treasury grows, supply grows
let new_treasury = treasury_lp + lp_in;
let new_supply = supply + fire_received;
// Step 3: Redeem all FIRE received
let lp_back = redemption_value(fire_received, new_treasury, new_supply, 100); // 1% fee
assert!(lp_back < lp_in,
"bond-redeem cycle must be unprofitable: put in {}, got back {}",
lp_in / DECIMAL_FACTOR, lp_back / DECIMAL_FACTOR);
// Calculate loss
let loss = lp_in - lp_back;
let loss_pct = (loss * 10000) / lp_in;
assert!(loss_pct > 0, "must have some loss");
}
#[test]
fn test_bond_redeem_cycle_unprofitable_even_high_discount() {
// Even with max 20% discount, cycle should be unprofitable
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let discount_bps = 2000u128; // 20% max discount
let oracle_price = DECIMAL_FACTOR;
let lp_in = 10_000_00000000u128;
let fire_received = (lp_in * (10000 + discount_bps) * DECIMAL_FACTOR) / (oracle_price * 10000);
let new_treasury = treasury_lp + lp_in;
let new_supply = supply + fire_received;
let lp_back = redemption_value(fire_received, new_treasury, new_supply, 0); // even 0% fee
assert!(lp_back < lp_in,
"even with 20% discount and 0% fee: put in {}, got back {}",
lp_in / DECIMAL_FACTOR, lp_back / DECIMAL_FACTOR);
}
#[test]
fn test_bond_redeem_unprofitable_tiny_treasury() {
// Edge case: tiny treasury, large bond — worst case for exploit
let treasury_lp = 10_00000000u128; // 10 LP only
let supply = 100_00000000u128; // 100 FIRE
let discount_bps = 2000u128; // 20%
let oracle_price = DECIMAL_FACTOR;
let lp_in = 100_00000000u128; // Bond 100 LP (10x treasury!)
let fire_received = (lp_in * (10000 + discount_bps) * DECIMAL_FACTOR) / (oracle_price * 10000);
let new_treasury = treasury_lp + lp_in;
let new_supply = supply + fire_received;
let lp_back = redemption_value(fire_received, new_treasury, new_supply, 0);
assert!(lp_back < lp_in,
"tiny treasury: put in {}, got back {}",
lp_in / DECIMAL_FACTOR, lp_back / DECIMAL_FACTOR);
}
#[test]
fn test_redeem_entire_supply() {
// Redeeming all FIRE should return all treasury LP (minus fee)
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let value = redemption_value(supply, treasury_lp, supply, 100);
// All supply redeemed → should get all treasury minus 1% fee
let expected = (treasury_lp * 9900) / 10000;
assert_eq!(value, expected);
}
#[test]
fn test_redeem_zero_treasury() {
// Treasury empty — redemption should return 0
let value = redemption_value(100_00000000, 0, 1_000_000_00000000, 0);
assert_eq!(value, 0, "empty treasury should return 0 LP");
}
#[test]
fn test_redeem_zero_supply() {
let rate = redemption_rate(100_000_00000000, 0);
assert_eq!(rate, 0, "zero supply should give zero rate");
}
// ── Bond pricing with floor guard ─────────────────────────────
#[test]
fn test_bond_price_oracle_above_floor() {
// Oracle = 0.20, floor = 0.10, discount = 10%, premium = 5%
let oracle = 20_000_000u128; // 0.20 LP/FIRE
let floor = 10_000_000u128; // 0.10 LP/FIRE
let price = bond_effective_price(oracle, floor, 1000, 500);
// oracle_discounted = 0.20 × 0.90 = 0.18
// floor_premium = 0.10 × 1.05 = 0.105
// max(0.18, 0.105) = 0.18
assert_eq!(price, 18_000_000);
}
#[test]
fn test_bond_price_floor_catches_low_oracle() {
// Oracle = 0.05 (below floor), floor = 0.10
let oracle = 5_000_000u128; // 0.05 LP/FIRE
let floor = 10_000_000u128; // 0.10 LP/FIRE
let price = bond_effective_price(oracle, floor, 1000, 500);
// oracle_discounted = 0.05 × 0.90 = 0.045
// floor_premium = 0.10 × 1.05 = 0.105
// max(0.045, 0.105) = 0.105 (floor wins)
assert_eq!(price, 10_500_000);
}
#[test]
fn test_bond_price_zero_oracle_uses_floor() {
let price = bond_effective_price(0, 10_000_000, 1000, 500);
// oracle = 0 → discounted = 0
// floor_premium = 0.105
assert_eq!(price, 10_500_000);
}
#[test]
fn test_bond_price_zero_floor_uses_oracle() {
let price = bond_effective_price(20_000_000, 0, 1000, 500);
// floor = 0 → premium = 0
// oracle_discounted = 0.18
assert_eq!(price, 18_000_000);
}
#[test]
fn test_bond_price_both_zero() {
let price = bond_effective_price(0, 0, 1000, 500);
assert_eq!(price, 0);
}
#[test]
fn test_bond_always_accretive() {
// Key test: bond price should always be >= floor price
// This guarantees every bond adds more to treasury backing than it dilutes
let floor = 10_000_000u128; // 0.10 LP/FIRE
for oracle in [0, 5_000_000, 10_000_000, 15_000_000, 50_000_000, 100_000_000] {
let price = bond_effective_price(oracle, floor, 1000, 500);
let floor_premium = (floor * 10500) / 10000;
assert!(
price >= floor_premium || oracle > floor,
"bond price {} below floor premium {} at oracle {}",
price, floor_premium, oracle
);
}
}
#[test]
fn test_bond_accretive_math() {
// Prove that bonding at effective_price never makes floor_price decrease
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let floor = redemption_rate(treasury_lp, supply); // 0.1 × 1e8 = 10_000_000
// Bond 10,000 LP at effective price
let lp_bonded = 10_000_00000000u128;
let effective_price = bond_effective_price(floor * 2, floor, 1000, 500);
let fire_minted = bond_fire_amount(lp_bonded, effective_price);
// New state
let new_treasury = treasury_lp + lp_bonded;
let new_supply = supply + fire_minted;
let new_floor = redemption_rate(new_treasury, new_supply);
assert!(
new_floor >= floor,
"floor decreased after bond: {} → {} (price={}, minted={})",
floor, new_floor, effective_price, fire_minted
);
}
#[test]
fn test_bond_accretive_at_floor_price() {
// Even when oracle = 0 and floor is used, bonding should be accretive
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let floor = redemption_rate(treasury_lp, supply);
let lp_bonded = 10_000_00000000u128;
// Oracle = 0, only floor + premium
let effective_price = bond_effective_price(0, floor, 1000, 500);
let fire_minted = bond_fire_amount(lp_bonded, effective_price);
let new_treasury = treasury_lp + lp_bonded;
let new_supply = supply + fire_minted;
let new_floor = redemption_rate(new_treasury, new_supply);
assert!(
new_floor >= floor,
"floor decreased at floor-only pricing: {} → {}",
floor, new_floor
);
}
#[test]
fn test_bond_fire_amount_basic() {
// 1000 LP at price 0.10 LP/FIRE → 10,000 FIRE
let fire = bond_fire_amount(1000_00000000, 10_000_000);
assert_eq!(fire, 10_000_00000000);
}
#[test]
fn test_bond_fire_amount_zero_price() {
assert_eq!(bond_fire_amount(1000_00000000, 0), 0);
}
// ══════════════════════════════════════════════════════════════
// Bonding epoch transition tests
// Simulates check_epoch + capacity logic from fire-bonding
// ══════════════════════════════════════════════════════════════
/// Simulate bonding contract state
struct BondingSim {
genesis: u64,
halving_epoch: u128,
epoch_start: u64,
total_bonded_fire: u128,
total_bonded_lp: u128,
}
impl BondingSim {
fn new(genesis: u64) -> Self {
let initial_epoch = 0u128;
Self {
genesis,
halving_epoch: initial_epoch,
epoch_start: genesis,
total_bonded_fire: 0,
total_bonded_lp: 0,
}
}
fn check_epoch(&mut self, current_height: u64) {
let elapsed = current_height.saturating_sub(self.genesis);
let calc_epoch = (elapsed / HALVING_INTERVAL) as u128;
if calc_epoch > self.halving_epoch {
let boundary = self.genesis + (calc_epoch as u64) * HALVING_INTERVAL;
self.halving_epoch = calc_epoch;
self.epoch_start = boundary;
self.total_bonded_fire = 0; // reset
}
}
fn current_rate(&self) -> u128 {
get_emission_rate_for_epoch(BONDING_EMISSION_RATE, self.halving_epoch)
}
fn unlocked(&self, current_height: u64) -> u128 {
let elapsed = (current_height as u128).saturating_sub(self.epoch_start as u128);
self.current_rate() * elapsed
}
fn available(&self, current_height: u64) -> u128 {
self.unlocked(current_height).saturating_sub(self.total_bonded_fire)
}
fn bond(&mut self, fire_amount: u128, lp_amount: u128, current_height: u64) -> Result<(), &'static str> {
self.check_epoch(current_height);
let avail = self.available(current_height);
if fire_amount > avail {
return Err("exceeds capacity");
}
self.total_bonded_fire += fire_amount;
self.total_bonded_lp += lp_amount;
Ok(())
}
}
#[test]
fn test_bonding_epoch0_basic_capacity() {
let sim = BondingSim::new(0);
// At block 1000, rate=200M, capacity = 200M × 1000
let avail = sim.available(1000);
assert_eq!(avail, BONDING_EMISSION_RATE * 1000);
assert_eq!(avail / DECIMAL_FACTOR, 1500); // 1500 FIRE (150M × 1000 blocks)
}
#[test]
fn test_bonding_epoch0_capacity_after_bonds() {
let mut sim = BondingSim::new(0);
let _ = sim.bond(1000 * DECIMAL_FACTOR, 100, 1000);
// Available = 1500 - 1000 = 500 FIRE
assert_eq!(sim.available(1000) / DECIMAL_FACTOR, 500);
}
#[test]
fn test_bonding_epoch_transition_resets_bonded() {
let mut sim = BondingSim::new(0);
// Bond 1000 FIRE in epoch 0
let _ = sim.bond(1000 * DECIMAL_FACTOR, 100, 50000);
assert_eq!(sim.total_bonded_fire, 1000 * DECIMAL_FACTOR);
// Cross halving boundary
sim.check_epoch(HALVING_INTERVAL + 100);
assert_eq!(sim.halving_epoch, 1);
assert_eq!(sim.total_bonded_fire, 0); // RESET
assert_eq!(sim.epoch_start, HALVING_INTERVAL);
}
#[test]
fn test_bonding_epoch1_halved_rate() {
let mut sim = BondingSim::new(0);
sim.check_epoch(HALVING_INTERVAL + 1000);
assert_eq!(sim.halving_epoch, 1);
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE / 2); // 75M
// Capacity in epoch 1: 75M × 1000 = 75B = 750 FIRE
assert_eq!(sim.available(HALVING_INTERVAL + 1000) / DECIMAL_FACTOR, 750);
}
#[test]
fn test_bonding_epoch2_quarter_rate() {
let mut sim = BondingSim::new(0);
sim.check_epoch(2 * HALVING_INTERVAL + 500);
assert_eq!(sim.halving_epoch, 2);
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE / 4); // 37.5M
// 37.5M × 500 = 18.75B = 187 FIRE
assert_eq!(sim.available(2 * HALVING_INTERVAL + 500) / DECIMAL_FACTOR, 187);
}
#[test]
fn test_bonding_leftover_not_carried_over() {
let mut sim = BondingSim::new(0);
// Epoch 0: bond only 100 FIRE out of possible ~157,500
let _ = sim.bond(100 * DECIMAL_FACTOR, 10, 50000);
let avail_before = sim.available(HALVING_INTERVAL - 1);
let max_epoch = BONDING_EMISSION_RATE * (HALVING_INTERVAL as u128 - 1) / DECIMAL_FACTOR;
assert!(avail_before / DECIMAL_FACTOR > max_epoch - 200); // ~157K - 100 = lots left
// Cross to epoch 1
sim.check_epoch(HALVING_INTERVAL + 1);
// New epoch: starts from 0, leftover is gone
let avail_after = sim.available(HALVING_INTERVAL + 1);
// Only 1 block × 75M (halved) = 75M units
assert_eq!(avail_after, BONDING_EMISSION_RATE / 2);
// Old leftover (210K FIRE) NOT available — stays in bonding pool on fire-token
}
#[test]
fn test_bonding_leftover_stays_in_pool() {
// Leftover doesn't disappear from fire-token bonding pool.
// It's just not accessible in this epoch. Future epochs can mint it.
let epoch0_used = 100 * DECIMAL_FACTOR;
let epoch0_budget = BONDING_EMISSION_RATE * HALVING_INTERVAL as u128;
let leftover = epoch0_budget - epoch0_used;
// Epoch 1 budget
let epoch1_budget = (BONDING_EMISSION_RATE / 2) * HALVING_INTERVAL as u128;
// Total available across all future epochs = leftover + epoch1 + epoch2 + ...
// = leftover + epoch1_budget × (1 + 0.5 + 0.25 + ...) ≈ leftover + 2×epoch1
// The leftover is still in the pool — fire-token tracks remaining globally
assert!(leftover > 0);
assert_eq!(leftover + epoch0_used, epoch0_budget);
}
#[test]
fn test_bonding_skip_multiple_epochs() {
// If nobody bonds for 3 epochs, check_epoch jumps straight there
let mut sim = BondingSim::new(0);
// Jump to epoch 3 directly
let height = 3 * HALVING_INTERVAL + 5000;
sim.check_epoch(height);
assert_eq!(sim.halving_epoch, 3);
assert_eq!(sim.epoch_start, 3 * HALVING_INTERVAL);
assert_eq!(sim.total_bonded_fire, 0);
// Rate = 200M >> 3 = 25M
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE / 8);
// Available = rate/8 × 5000
let expected = (BONDING_EMISSION_RATE / 8) * 5000 / DECIMAL_FACTOR;
assert_eq!(sim.available(height) / DECIMAL_FACTOR, expected);
}
#[test]
fn test_bonding_cannot_exploit_old_epoch_capacity() {
let mut sim = BondingSim::new(0);
// Epoch 0: accumulate large capacity (don't bond)
// At block 104999 (end of epoch 0): capacity = 200M × 104999 ≈ 21T = 210K FIRE
// Now cross to epoch 1
sim.check_epoch(HALVING_INTERVAL + 1);
// Attacker tries to bond using old epoch's accumulated capacity
// But total_bonded_fire was reset, and epoch_start is new boundary
// Available = halved rate × 1 block
let avail = sim.available(HALVING_INTERVAL + 1);
assert_eq!(avail, BONDING_EMISSION_RATE / 2);
// Try to bond 1000 FIRE (way more than available)
let result = sim.bond(1000 * DECIMAL_FACTOR, 100, HALVING_INTERVAL + 1);
assert_eq!(result, Err("exceeds capacity"));
}
#[test]
fn test_bonding_cannot_exploit_by_not_calling_check_epoch() {
// check_epoch is called inside bond() — user can't skip it
let mut sim = BondingSim::new(0);
// If somehow check_epoch wasn't called and we're in epoch 1:
// epoch_start still = 0, halving_epoch = 0
// unlocked = 200M × (HALVING + 1000) = huge
// BUT bond() always calls check_epoch first
// After check: epoch_start = HALVING, bonded = 0, rate = 100M
// unlocked = 100M × 1000 = small
let result = sim.bond(300_000 * DECIMAL_FACTOR, 10000, HALVING_INTERVAL + 1000);
// check_epoch triggered inside bond → reset → only 100M × 1000 available = 1000 FIRE
assert_eq!(result, Err("exceeds capacity"));
assert_eq!(sim.halving_epoch, 1); // epoch was updated
}
#[test]
fn test_bonding_rate_after_many_halvings() {
let mut sim = BondingSim::new(0);
// Epoch 10: rate = 200M >> 10 = 195,312
sim.check_epoch(10 * HALVING_INTERVAL + 1000);
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE >> 10);
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE >> 10);
let rate = BONDING_EMISSION_RATE >> 10;
let avail = sim.available(10 * HALVING_INTERVAL + 1000);
assert_eq!(avail, rate * 1000);
assert!(avail < 2 * DECIMAL_FACTOR); // less than 2 FIRE
}
#[test]
fn test_bonding_rate_eventually_zero() {
let mut sim = BondingSim::new(0);
// Epoch 30: rate = 200M >> 30 = 0
sim.check_epoch(30 * HALVING_INTERVAL + 1000);
assert_eq!(sim.current_rate(), 0);
assert_eq!(sim.available(30 * HALVING_INTERVAL + 1000), 0);
// Bonding impossible
let result = sim.bond(1, 1, 30 * HALVING_INTERVAL + 1000);
assert_eq!(result, Err("exceeds capacity"));
}
#[test]
fn test_bonding_genesis_not_at_zero() {
// Deploy at block 946000 (like mainnet)
let mut sim = BondingSim::new(946_000);
// Initial epoch: (0) / HALVING = 0 since elapsed = 0
assert_eq!(sim.halving_epoch, 0);
assert_eq!(sim.epoch_start, 946_000);
// At block 950000: elapsed = 4000, still epoch 0
sim.check_epoch(950_000);
assert_eq!(sim.halving_epoch, 0);
let expected = BONDING_EMISSION_RATE * 4000 / DECIMAL_FACTOR;
assert_eq!(sim.available(950_000) / DECIMAL_FACTOR, expected);
// Cross first halving: genesis + HALVING = 946000 + 105000 = 1051000
sim.check_epoch(1_051_001);
assert_eq!(sim.halving_epoch, 1);
assert_eq!(sim.epoch_start, 946_000 + HALVING_INTERVAL);
assert_eq!(sim.current_rate(), BONDING_EMISSION_RATE / 2);
}
#[test]
fn test_bonding_multiple_bonds_same_epoch() {
let mut sim = BondingSim::new(0);
// Bond 500 FIRE at block 1000
let _ = sim.bond(500 * DECIMAL_FACTOR, 50, 1000);
assert_eq!(sim.total_bonded_fire / DECIMAL_FACTOR, 500);
// Bond 300 more at block 2000
let _ = sim.bond(300 * DECIMAL_FACTOR, 30, 2000);
assert_eq!(sim.total_bonded_fire / DECIMAL_FACTOR, 800);
let expected = BONDING_EMISSION_RATE * 2000 / DECIMAL_FACTOR - 800;
assert_eq!(sim.available(2000) / DECIMAL_FACTOR, expected);
}
// ══════════════════════════════════════════════════════════════
// Bond-redeem cycle: isolated bonder (no stakers)
// ══════════════════════════════════════════════════════════════
#[test]
fn test_bond_redeem_solo_bonder_loses_only_fee() {
// Bonder is the ONLY participant. No stakers. No other FIRE supply.
// Bond LP → get FIRE → redeem FIRE → should lose only 1% fee.
let treasury_lp_before = 0u128;
let supply_before = 0u128;
let lp_bonded = 3000_00000000u128; // 3000 LP
// Bond at some price — bonder gets FIRE
let bond_price = 214u128; // LP per FIRE scaled by 1e8
let fire_received = bond_fire_amount(lp_bonded, bond_price);
// After bond: treasury has LP, supply has FIRE (only from this bond)
let treasury_after_bond = treasury_lp_before + lp_bonded;
let supply_after_bond = supply_before + fire_received;
// Redeem ALL FIRE with 1% fee
let lp_back = redemption_value(fire_received, treasury_after_bond, supply_after_bond, 100);
// Should get back ~99% of LP
let loss = lp_bonded - lp_back;
let loss_pct = (loss * 10000) / lp_bonded;
assert!(loss_pct >= 99 && loss_pct <= 101,
"solo bonder should lose ~1% (fee only), got {}bps loss. in={}, back={}, loss={}",
loss_pct, lp_bonded, lp_back, loss);
}
#[test]
fn test_bond_redeem_diluted_by_staking_emission() {
// Bonder + staking emission. Staking adds FIRE supply but no treasury LP.
// Bonder's redemption is diluted — gets back less.
// Use realistic price where staking emission is significant vs bond FIRE.
let bond_price = 23809u128; // 100 LP locked scenario (~$0.476/FIRE)
let lp_bonded = 10_00000000u128; // 10 LP
let fire_from_bond = bond_fire_amount(lp_bonded, bond_price);
// fire = 10e8 * 1e8 / 23809 ≈ 42,001 FIRE (420 × 1e8 units)
// Staking emitted much more FIRE (not backed by treasury LP)
let staking_emission = 100_000_00000000u128; // 100K FIRE
let treasury = lp_bonded; // only 10 LP from bond
let total_supply = fire_from_bond + staking_emission;
let lp_back = redemption_value(fire_from_bond, treasury, total_supply, 100);
// Bonder gets much less than 99% because staking diluted the floor
let loss_pct = ((lp_bonded - lp_back) * 100) / lp_bonded;
assert!(loss_pct > 10,
"diluted bonder should lose >10%, got {}%. fire_bond={}, staking={}, supply={}",
loss_pct, fire_from_bond / DECIMAL_FACTOR, staking_emission / DECIMAL_FACTOR,
total_supply / DECIMAL_FACTOR);
// Verify: more staking emission = more loss for bonder
let staking_emission_2x = 200_000_00000000u128;
let total_supply_2x = fire_from_bond + staking_emission_2x;
let lp_back_2x = redemption_value(fire_from_bond, treasury, total_supply_2x, 100);
assert!(lp_back_2x < lp_back,
"more staking emission should mean more dilution: {} vs {}", lp_back_2x, lp_back);
}
#[test]
fn test_bond_redeem_with_proportional_treasury() {
// If treasury LP grows proportionally with supply (many bonders, no stakers),
// every bonder loses only ~1%.
let bond_price = 214u128;
// 10 bonders each bond 1000 LP
let mut treasury = 0u128;
let mut supply = 0u128;
for _ in 0..10 {
let lp = 1000_00000000u128;
let fire = bond_fire_amount(lp, bond_price);
treasury += lp;
supply += fire;
}
// Last bonder redeems
let last_fire = bond_fire_amount(1000_00000000, bond_price);
let lp_back = redemption_value(last_fire, treasury, supply, 100);
let loss_pct = ((1000_00000000 - lp_back) * 10000) / 1000_00000000;
assert!(loss_pct >= 99 && loss_pct <= 101,
"proportional treasury: bonder should lose ~1%, got {}bps", loss_pct);
}
// ══════════════════════════════════════════════════════════════
// Vesting across epoch boundary
// ══════════════════════════════════════════════════════════════
#[test]
fn test_vesting_spans_halving_boundary() {
// Bond at block 104,900 (100 blocks before halving)
// Vesting = 1,050 blocks → ends at 105,950 (past halving)
let fire_amount = 5000 * DECIMAL_FACTOR;
let start = 104_900u128;
let end = start + 1_050; // 105,950
// Claim at 50% (block 105,425 — past halving boundary)
let now_50 = start + 525;
assert!(now_50 > HALVING_INTERVAL as u128); // past halving
let vested_50 = fire_amount * (now_50 - start) / (end - start);
let claimable_50 = vested_50;
let pct = claimable_50 * 100 / fire_amount;
assert!(pct >= 49 && pct <= 51, "~50% vested at midpoint: {}%", pct);
// Claim at 100% (block 105,950)
let now_full = end;
let vested_full = fire_amount; // past end
assert_eq!(vested_full, fire_amount);
// Halving doesn't affect vesting — FIRE was already minted
}
#[test]
fn test_vesting_entirely_in_next_epoch() {
// Bond at block 104,990 (10 blocks before halving)
// Vesting = 1,050 → ends at 106,040
// Almost entire vesting is in epoch 1
let fire_amount = 3000 * DECIMAL_FACTOR;
let start = 104_990u128;
let end = start + 1_050; // 106,040
// At halving boundary: only 10/1050 ≈ 0.95% vested
let now_halving = HALVING_INTERVAL as u128;
let vested = fire_amount * (now_halving - start) / (end - start);
let pct = vested * 1000 / fire_amount; // permille
assert!(pct < 15, "less than 1.5% vested at halving: {} permille", pct);
// Full vest in epoch 1
let now_full = end + 100;
let vested_full = fire_amount; // past end
assert_eq!(vested_full, fire_amount);
}
#[test]
fn test_vesting_independent_of_epoch_reset() {
// Simulate: bond → halving → check_epoch resets bonded counter
// Vesting should be unaffected
let mut sim = BondingSim::new(0);
// Bond near end of epoch 0
let _ = sim.bond(500 * DECIMAL_FACTOR, 10, 104_000);
let bonded_before = sim.total_bonded_fire;
assert_eq!(bonded_before, 500 * DECIMAL_FACTOR);
// Cross halving
sim.check_epoch(HALVING_INTERVAL + 100);
assert_eq!(sim.total_bonded_fire, 0); // reset!
// But the 500 FIRE from the bond are already minted.
// Vesting continues independently — bonded_fire reset doesn't
// affect already-minted FIRE on the bonding contract.
// The claim logic reads from position token, not from bonded counter.
// Verify: new bonds in epoch 1 work independently
// Rate halved to 75M, at +2000 blocks: capacity = 75M × 2000 = 150B = 1500 FIRE
let _ = sim.bond(100 * DECIMAL_FACTOR, 5, HALVING_INTERVAL + 2000);
assert_eq!(sim.total_bonded_fire, 100 * DECIMAL_FACTOR);
// Old 500 FIRE vesting still happens (not tracked in sim, but in contract)
}
#[test]
fn test_multiple_bonds_different_epochs_vest_independently() {
// Bond A in epoch 0, Bond B in epoch 1
// Both vest independently
let fire_a = 1000 * DECIMAL_FACTOR;
let start_a = 100_000u128;
let end_a = start_a + 1_050;
let fire_b = 500 * DECIMAL_FACTOR;
let start_b = (HALVING_INTERVAL as u128) + 5_000;
let end_b = start_b + 1_050;
// At block 110,050 — bond A fully vested, bond B at ~0%
let now = (HALVING_INTERVAL as u128) + 5_000;
// Bond A: past end (101,050), fully vested
let vested_a = fire_a; // now > end_a
assert_eq!(vested_a, fire_a);
// Bond B: just started, 0 blocks elapsed
let elapsed_b = now.saturating_sub(start_b);
assert_eq!(elapsed_b, 0);
// 0 vested for B
// At block 111,050 — bond B fully vested too
let now2 = end_b;
let vested_b = fire_b;
assert_eq!(vested_b, fire_b);
// Total claimed = A + B
let total = vested_a + vested_b;
assert_eq!(total, 1500 * DECIMAL_FACTOR);
}
#[test]
fn test_bond_right_before_halving_gets_epoch0_price() {
// Price is calculated at bond() time — epoch 0 rate
// Even though vesting extends into epoch 1
let sim = BondingSim::new(0);
// At block 104,999 (last block of epoch 0)
let rate = sim.current_rate();
assert_eq!(rate, BONDING_EMISSION_RATE); // epoch 0 full rate
// Bond happens at epoch 0 price
// After halving, rate halves but bond price was already locked in
}
#[test]
fn test_bond_right_after_halving_gets_epoch1_price() {
let mut sim = BondingSim::new(0);
sim.check_epoch(HALVING_INTERVAL + 1);
let rate = sim.current_rate();
assert_eq!(rate, BONDING_EMISSION_RATE / 2); // epoch 1 halved rate
}
#[test]
fn test_partial_claims_across_boundary_sum_correctly() {
let fire_amount = 10_000 * DECIMAL_FACTOR;
let start = 104_500u128; // 500 blocks before halving
let end = start + 1_050; // 105,550
let mut claimed = 0u128;
// Claim 1: at halving boundary (block 105,000)
let now1 = HALVING_INTERVAL as u128;
let vested1 = fire_amount * (now1 - start) / (end - start);
let claimable1 = vested1 - claimed;
claimed = vested1;
// Claim 2: at full vest (block 105,550)
let now2 = end;
let vested2 = fire_amount; // past end
let claimable2 = vested2 - claimed;
claimed = vested2;
assert_eq!(claimable1 + claimable2, fire_amount,
"partial claims across boundary must sum to total: {} + {} = {} vs {}",
claimable1 / DECIMAL_FACTOR, claimable2 / DECIMAL_FACTOR,
(claimable1 + claimable2) / DECIMAL_FACTOR, fire_amount / DECIMAL_FACTOR);
}
// ══════════════════════════════════════════════════════════════
// Pre-create epoch: no conflict with active epoch
// ══════════════════════════════════════════════════════════════
#[test]
fn test_precreate_epoch_does_not_affect_active() {
// Epoch 0 active at height 50000 (within 0..104999)
// Someone pre-creates epoch 1 (starts at 105000)
// Bonding should still see epoch 0's state, not epoch 1's empty state
// Simulate: "which epoch is active at height X?"
// active_epoch_index(height) = height / HALVING_INTERVAL
// But in factory terms, the INDEX depends on when epochs were created.
// Factory creates epochs sequentially:
// index 0 → abs_epoch = height/dur at creation time
// index 1 → abs_epoch = index_0_abs + 1
// GetCurrentEpochIndex checks: which index has start_block <= height?
let dur = HALVING_INTERVAL as u128;
// Epoch 0: abs=0, start=0, expiry=104999
// Epoch 1: abs=1, start=105000, expiry=209999 (pre-created)
let epochs = vec![
(0u128, 0u128), // index 0: abs=0, start=0
(1u128, dur), // index 1: abs=1, start=105000
];
// At height 50000: active should be index 0 (start=0 <= 50000)
let height = 50000u128;
let mut active_idx = 0u128;
for (i, (_, start)) in epochs.iter().enumerate().rev() {
if height >= *start {
active_idx = i as u128;
break;
}
}
assert_eq!(active_idx, 0, "at height 50000, active epoch should be 0");
// At height 105001: active should be index 1
let height2 = 105001u128;
let mut active_idx2 = 0u128;
for (i, (_, start)) in epochs.iter().enumerate().rev() {
if height2 >= *start {
active_idx2 = i as u128;
break;
}
}
assert_eq!(active_idx2, 1, "at height 105001, active epoch should be 1");
}
#[test]
fn test_precreate_multiple_future_epochs() {
// Edge case: someone creates epoch 0, 1, 2 at height 10
// Only epoch 0 should be active
let dur = HALVING_INTERVAL as u128;
let epochs = vec![
(0u128, 0u128), // start = 0
(1u128, dur), // start = 105000
(2u128, dur * 2), // start = 210000
];
let height = 10u128;
let mut active = 0u128;
for (i, (_, start)) in epochs.iter().enumerate().rev() {
if height >= *start {
active = i as u128;
break;
}
}
assert_eq!(active, 0, "only epoch 0 active at height 10");
}
#[test]
fn test_oracle_ignores_precreated_epoch() {
// Oracle price should use active epoch's locked LP, not pre-created empty one
// Active epoch (0): 100 LP locked
let active_locked = 100 * DECIMAL_FACTOR;
// Pre-created epoch (1): 0 LP locked
let precreated_locked = 0u128;
// Oracle should use active's locked LP
let correct_price = staking_oracle_price(active_locked);
let wrong_price = staking_oracle_price(precreated_locked); // bootstrap
assert!(correct_price > wrong_price,
"active epoch price ({}) should be higher than bootstrap ({})",
correct_price, wrong_price);
// If oracle used pre-created epoch, price would be bootstrap (224)
// This would make bonds too cheap
assert_eq!(wrong_price, 224); // bootstrap
assert_eq!(correct_price, 22408); // 100 LP locked
}
// ══════════════════════════════════════════════════════════════
// Staking-based oracle pricing
// ══════════════════════════════════════════════════════════════
const ANNUAL_STAKING_EMISSION: u128 = STAKING_EMISSION_RATE * YEAR as u128;
/// Simulates oracle: price = max(locked_lp, 1 LP) × DECIMAL / annual_emission
fn staking_oracle_price(locked_lp_units: u128) -> u128 {
let effective = if locked_lp_units < DECIMAL_FACTOR { DECIMAL_FACTOR } else { locked_lp_units };
(effective * DECIMAL_FACTOR) / ANNUAL_STAKING_EMISSION
}
#[test]
fn test_oracle_bootstrap_price() {
// 0 stakers → fallback 1 LP → cheapest FIRE
let price = staking_oracle_price(0);
assert_eq!(price, 224); // 1e8 * 1e8 / 44.625e12 = 224
// ~$0.0048 per FIRE at LP=$2000
}
#[test]
fn test_oracle_10_lp_locked() {
let price = staking_oracle_price(10 * DECIMAL_FACTOR);
assert_eq!(price, 2240);
// ~$0.048 per FIRE
}
#[test]
fn test_oracle_100_lp_locked() {
let price = staking_oracle_price(100 * DECIMAL_FACTOR);
assert_eq!(price, 22408);
// ~$0.476 per FIRE
}
#[test]
fn test_oracle_1000_lp_locked() {
let price = staking_oracle_price(1000 * DECIMAL_FACTOR);
assert_eq!(price, 224089);
// ~$4.76 per FIRE
}
#[test]
fn test_oracle_price_halves_with_epoch() {
// Oracle price should double each epoch (emission halves → FIRE more expensive)
let locked = 100 * DECIMAL_FACTOR;
let p0 = staking_oracle_price(locked); // epoch 0 rate
// Simulate epoch 1: rate halved → annual emission halved → price doubles
let rate_1 = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 1);
let annual_1 = rate_1 * YEAR as u128;
let p1 = locked * DECIMAL_FACTOR / annual_1;
// Epoch 2
let rate_2 = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 2);
let annual_2 = rate_2 * YEAR as u128;
let p2 = locked * DECIMAL_FACTOR / annual_2;
assert!(p1 > p0, "epoch 1 price should be higher: {} vs {}", p1, p0);
assert!(p2 > p1, "epoch 2 price should be higher: {} vs {}", p2, p1);
// Price roughly doubles each epoch (within rounding)
let ratio_1 = p1 * 100 / p0;
let ratio_2 = p2 * 100 / p1;
assert!(ratio_1 >= 195 && ratio_1 <= 205, "epoch 0→1 ratio: {}%", ratio_1);
assert!(ratio_2 >= 195 && ratio_2 <= 205, "epoch 1→2 ratio: {}%", ratio_2);
}
#[test]
fn test_oracle_epoch0_vs_epoch1_price() {
// Concrete numbers: 100 LP locked
let locked = 100 * DECIMAL_FACTOR;
// Epoch 0: rate=850M, annual=44,625,000,000,000
let annual_0 = STAKING_EMISSION_RATE * YEAR as u128;
let price_0 = locked * DECIMAL_FACTOR / annual_0;
// Epoch 1: rate=425M, annual=22,312,500,000,000
let rate_1 = STAKING_EMISSION_RATE >> 1;
let annual_1 = rate_1 * YEAR as u128;
let price_1 = locked * DECIMAL_FACTOR / annual_1;
assert_eq!(price_0, 22408); // epoch 0
// Epoch 1 ~2x (±1 from integer rounding)
assert!(price_1 >= 44816 && price_1 <= 44818,
"epoch 1 price: {} (expected ~44817)", price_1);
}
#[test]
fn test_oracle_late_epoch_price_very_high() {
// At epoch 10: rate = 850M >> 10 = 830,078
// Annual = 830,078 × 52,500 = 43,579,095,000 (very small)
// Price = 100 LP / 43B_units = very high
let locked = 100 * DECIMAL_FACTOR;
let rate_10 = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 10);
let annual_10 = rate_10 * YEAR as u128;
let price_10 = locked * DECIMAL_FACTOR / annual_10;
// Should be ~1024x higher than epoch 0 (2^10)
let price_0 = locked * DECIMAL_FACTOR / (STAKING_EMISSION_RATE * YEAR as u128);
let ratio = price_10 / price_0;
assert!(ratio >= 1020 && ratio <= 1028,
"epoch 10 should be ~1024x epoch 0: {}x", ratio);
}
#[test]
fn test_oracle_emission_zero_returns_max() {
// After epoch 30, rate = 0. Oracle should handle gracefully.
let rate_30 = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 30);
assert_eq!(rate_30, 0);
let annual = rate_30 * YEAR as u128;
assert_eq!(annual, 0);
// Division by zero → price should be u128::MAX or similar sentinel
// In oracle contract: returns u128::MAX
}
#[test]
fn test_oracle_price_linear_with_locked_lp() {
let p1 = staking_oracle_price(100 * DECIMAL_FACTOR);
let p2 = staking_oracle_price(200 * DECIMAL_FACTOR);
// Should be exactly 2x (linear)
assert_eq!(p2 / p1, 2);
}
#[test]
fn test_oracle_price_consistency() {
// At bootstrap: 1 LP locked → ~446,250 FIRE/year yield (850M × 52500 / 1e8)
// Price = 1 LP / 446,250 FIRE ≈ 0.00000224 LP/FIRE
let price = staking_oracle_price(DECIMAL_FACTOR);
let implied_yield = DECIMAL_FACTOR * DECIMAL_FACTOR / price;
// Allow small rounding: ~446,250 ± 1% (integer division, 850M × 52500 / 1e8)
let expected = STAKING_EMISSION_RATE * YEAR as u128 / DECIMAL_FACTOR;
let diff = if implied_yield / DECIMAL_FACTOR > expected {
implied_yield / DECIMAL_FACTOR - expected
} else {
expected - implied_yield / DECIMAL_FACTOR
};
assert!(diff <= expected / 100,
"implied yield {}, expected ~{}", implied_yield / DECIMAL_FACTOR, expected);
}
// ══════════════════════════════════════════════════════════════
// Bond pricing without floor premium (current: max(oracle_disc, floor))
// ══════════════════════════════════════════════════════════════
#[test]
fn test_bond_price_no_premium_floor_dominates() {
// Oracle discounted < floor → floor wins (no 5% markup)
let oracle = 5_000_000u128;
let floor = 10_000_000u128;
let price = bond_effective_price(oracle, floor, 1000, 0); // 0 premium
assert_eq!(price, floor); // floor exactly, no premium
}
#[test]
fn test_bond_price_no_premium_oracle_dominates() {
let oracle = 20_000_000u128;
let floor = 10_000_000u128;
let price = bond_effective_price(oracle, floor, 1000, 0);
assert_eq!(price, 18_000_000); // oracle × 0.9
}
#[test]
fn test_bond_redeem_cycle_with_floor_no_premium() {
// Without 5% floor premium, bond-redeem is unprofitable only by 1% fee
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let floor = redemption_rate(treasury_lp, supply); // 10_000_000
// Bond at exactly floor price (worst case: oracle=0, no premium)
let effective = bond_effective_price(0, floor, 1000, 0);
assert_eq!(effective, floor); // bond at floor exactly
let lp_in = 10_000_00000000u128;
let fire_received = bond_fire_amount(lp_in, effective);
let new_treasury = treasury_lp + lp_in;
let new_supply = supply + fire_received;
// Redeem with 1% fee
let lp_back = redemption_value(fire_received, new_treasury, new_supply, 100);
// Should still be unprofitable
assert!(lp_back < lp_in,
"floor-only bond+redeem must be unprofitable: in={}, back={}",
lp_in, lp_back);
let loss_bps = ((lp_in - lp_back) * 10000) / lp_in;
assert!(loss_bps >= 90, "loss should be ~1% from fee, got {} bps", loss_bps);
}
#[test]
fn test_bond_at_floor_still_accretive_no_premium() {
// Even without premium, bonding at floor should not decrease floor
// Because bond at floor = proportional → floor unchanged (not decreased)
let treasury_lp = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let floor = redemption_rate(treasury_lp, supply);
let lp_bonded = 10_000_00000000u128;
let fire_minted = bond_fire_amount(lp_bonded, floor);
let new_treasury = treasury_lp + lp_bonded;
let new_supply = supply + fire_minted;
let new_floor = redemption_rate(new_treasury, new_supply);
// Floor should be unchanged (not decreased) when bonding at exactly floor
assert!(new_floor >= floor,
"floor must not decrease: {} → {}", floor, new_floor);
}
// ══════════════════════════════════════════════════════════════
// Rate limiting math
// ══════════════════════════════════════════════════════════════
#[test]
fn test_bonding_capacity_grows_linearly() {
let epoch_start = 0u128;
for block in [100, 1000, 10000, 52500] {
let capacity = BONDING_EMISSION_RATE * (block - epoch_start);
let expected_fire = BONDING_EMISSION_RATE * block / DECIMAL_FACTOR;
assert_eq!(capacity / DECIMAL_FACTOR, expected_fire,
"at block {}: capacity {} FIRE", block, capacity / DECIMAL_FACTOR);
}
}
#[test]
fn test_bonding_capacity_per_epoch() {
// Full epoch capacity = BONDING_EMISSION_RATE × HALVING_INTERVAL
// This equals HALF the bonding pool (geometric: epoch 0 = 50%, epoch 1 = 25%, ...)
let epoch_capacity = BONDING_EMISSION_RATE * HALVING_INTERVAL as u128;
assert_eq!(epoch_capacity, BONDING_EMISSION_POOL / 2,
"epoch 0 bonding = half of total bonding pool");
}
#[test]
fn test_available_after_bonds() {
let elapsed = 10000u128;
let capacity = BONDING_EMISSION_RATE * elapsed;
let bonded = 500 * DECIMAL_FACTOR; // 500 FIRE bonded
let available = capacity - bonded;
let expected = BONDING_EMISSION_RATE * elapsed - bonded;
assert_eq!(available, expected);
}
// ══════════════════════════════════════════════════════════════
// Vesting math
// ══════════════════════════════════════════════════════════════
#[test]
fn test_vesting_linear() {
let fire_amount = 10000 * DECIMAL_FACTOR;
let start = 1000u128;
let end = 2008u128; // 1008 blocks vesting
let claimed = 0u128;
// At 50%
let now = 1504u128;
let elapsed = now - start;
let duration = end - start;
let vested = fire_amount * elapsed / duration;
let claimable = vested - claimed;
// ~50% should be vested
let pct = claimable * 100 / fire_amount;
assert!(pct >= 49 && pct <= 51, "50% vest: got {}%", pct);
}
#[test]
fn test_vesting_full() {
let fire_amount = 10000 * DECIMAL_FACTOR;
let start = 1000u128;
let end = 2008u128;
// Past end
let now = 3000u128;
let vested = fire_amount; // >= end → full
let claimed = 0u128;
let claimable = vested - claimed;
assert_eq!(claimable, fire_amount);
}
#[test]
fn test_vesting_partial_claims_sum_to_total() {
let fire_amount = 10000 * DECIMAL_FACTOR;
let start = 0u128;
let end = 1008u128;
let mut claimed = 0u128;
let mut total_claimed = 0u128;
// Claim at 25%, 50%, 75%, 100%
for now in [252, 504, 756, 1008] {
let vested = if now >= end {
fire_amount
} else {
fire_amount * (now - start) / (end - start)
};
let claimable = vested - claimed;
claimed = vested;
total_claimed += claimable;
}
assert_eq!(total_claimed, fire_amount,
"partial claims must sum to total: {} vs {}", total_claimed, fire_amount);
}
#[test]
fn test_vesting_before_start() {
let fire_amount = 10000 * DECIMAL_FACTOR;
let start = 1000u128;
let now = 500u128;
// now <= start → 0 vested
assert!(now <= start);
// claimable = 0
}
// ══════════════════════════════════════════════════════════════
// Emission rate halving edge cases
// ══════════════════════════════════════════════════════════════
#[test]
fn test_emission_epoch_29_nonzero() {
// 850M >> 29 = 1, last nonzero epoch
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 29);
assert!(rate > 0, "epoch 29 should still have nonzero rate: {}", rate);
}
#[test]
fn test_emission_epoch_30_zero() {
// 850M >> 30 = 0
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 30);
assert_eq!(rate, 0, "epoch 30 should be zero (850M >> 30 = 0)");
}
#[test]
fn test_emission_epoch_64_zero() {
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 64);
assert_eq!(rate, 0, "epoch 64+ returns 0 by guard");
}
#[test]
fn test_emission_total_all_epochs() {
// Sum emission over all 64 epochs
let mut total = 0u128;
for epoch in 0..64 {
let staking = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch);
let bonding = get_emission_rate_for_epoch(BONDING_EMISSION_RATE, epoch);
total += (staking + bonding) * HALVING_INTERVAL as u128;
}
// Should be very close to MAX_SUPPLY (within rounding)
let diff = if total > MAX_SUPPLY { total - MAX_SUPPLY } else { MAX_SUPPLY - total };
assert!(diff < DECIMAL_FACTOR, // less than 1 FIRE difference
"total emission {} vs max supply {}, diff {}",
total, MAX_SUPPLY, diff);
}
// ══════════════════════════════════════════════════════════════
// Floor invariant under redemption with fee
// ══════════════════════════════════════════════════════════════
#[test]
fn test_floor_increases_with_fee() {
let mut treasury = 100_000_00000000u128;
let mut supply = 1_000_000_00000000u128;
let fee_bps = 100u128; // 1%
let floor_before = redemption_rate(treasury, supply);
// Redeem 10,000 FIRE
let redeem_amount = 10_000_00000000u128;
let lp_returned = redemption_value(redeem_amount, treasury, supply, fee_bps);
let fee_lp = (redeem_amount * redemption_rate(treasury, supply) / DECIMAL_FACTOR) - lp_returned;
treasury -= lp_returned; // fee stays in treasury
supply -= redeem_amount;
let floor_after = redemption_rate(treasury, supply);
assert!(floor_after >= floor_before,
"floor should increase with fee: {} → {}", floor_before, floor_after);
}
#[test]
fn test_floor_stable_without_fee() {
let treasury = 100_000_00000000u128;
let supply = 1_000_000_00000000u128;
let floor_before = redemption_rate(treasury, supply);
let redeem_amount = 10_000_00000000u128;
let lp_returned = redemption_value(redeem_amount, treasury, supply, 0);
let new_treasury = treasury - lp_returned;
let new_supply = supply - redeem_amount;
let floor_after = redemption_rate(new_treasury, new_supply);
assert_eq!(floor_after, floor_before,
"floor should be unchanged without fee: {} → {}", floor_before, floor_after);
}
// ══════════════════════════════════════════════════════════════
// Epoch creation limit (max current_abs + 1)
// ══════════════════════════════════════════════════════════════
#[test]
fn test_epoch_limit_current_plus_one() {
// At height 50000, current_abs = 50000/105000 = 0
// Can create epoch 0 and 1 (pre-create), but not 2+
let dur = HALVING_INTERVAL as u128;
let h = 50000u128;
let current_abs = h / dur; // 0
assert_eq!(current_abs, 0);
assert!(0 <= current_abs + 1); // epoch 0 ok
assert!(1 <= current_abs + 1); // epoch 1 ok (pre-create)
assert!(2 > current_abs + 1); // epoch 2 blocked
}
#[test]
fn test_epoch_limit_at_boundary() {
// At height 105000, current_abs = 1
// Can create epoch 1 and 2, but not 3+
let dur = HALVING_INTERVAL as u128;
let h = 105000u128;
let current_abs = h / dur; // 1
assert_eq!(current_abs, 1);
assert!(1 <= current_abs + 1);
assert!(2 <= current_abs + 1);
assert!(3 > current_abs + 1);
}
#[test]
fn test_epoch_limit_prevents_dos() {
// Attacker at height 50000 tries to create 100 future epochs
// Should be blocked at epoch 2 (current_abs=0, max=1)
let dur = HALVING_INTERVAL as u128;
let h = 50000u128;
let current_abs = h / dur;
let mut blocked_count = 0;
for target in 0..100 {
if target > current_abs + 1 {
blocked_count += 1;
}
}
assert_eq!(blocked_count, 98); // only 0 and 1 allowed
}
// ══════════════════════════════════════════════════════════════
// Zero-FIRE bond prevention
// ══════════════════════════════════════════════════════════════
#[test]
fn test_zero_fire_bond_at_max_price() {
// If oracle returns u128::MAX, fire_amount = lp * DECIMAL / MAX ≈ 0
let lp = 1000 * DECIMAL_FACTOR;
let price = u128::MAX;
let fire = bond_fire_amount(lp, price);
assert_eq!(fire, 0, "tiny LP at max price should yield 0 FIRE");
}
#[test]
fn test_zero_fire_bond_tiny_lp() {
// Very small LP at high price
let lp = 1u128; // 1 base unit
let price = DECIMAL_FACTOR; // 1 LP per FIRE
let fire = bond_fire_amount(lp, price);
assert_eq!(fire, 1, "1 unit LP at 1:1 price = 1 unit FIRE");
// Even tinier
let lp2 = 1u128;
let price2 = DECIMAL_FACTOR * 1000; // 1000 LP per FIRE
let fire2 = bond_fire_amount(lp2, price2);
assert_eq!(fire2, 0, "1 unit at 1000:1 = 0 FIRE");
}
// ══════════════════════════════════════════════════════════════
// Double decrement prevention (RedeemExpired removed, claim only)
// ══════════════════════════════════════════════════════════════
#[test]
fn test_no_double_decrement_split_position() {
// Simulate: stake 100 LP (6mo lock) → split → claim after expiry → redeem wLP
// total_locked_lp should decrement ONCE (in claim), not twice
let stake_amount = 100 * DECIMAL_FACTOR;
let mut total_locked_lp = 0u128;
// Stake with 6mo lock → increment
total_locked_lp += stake_amount;
assert_eq!(total_locked_lp, stake_amount);
// Split → no effect on total_locked_lp
// (split doesn't change locked accounting)
// claim_rewards after expiry for split position:
// lock_duration >= SIX_MONTHS → decrement
total_locked_lp = total_locked_lp.saturating_sub(stake_amount);
assert_eq!(total_locked_lp, 0);
// RedeemExpired: NO decrement (removed)
// If we decremented here too, would be double:
// total_locked_lp = total_locked_lp.saturating_sub(stake_amount);
// Would be 0 due to saturating_sub but conceptually wrong
// Final: total_locked_lp = 0 ✓
assert_eq!(total_locked_lp, 0);
}
#[test]
fn test_no_double_decrement_non_split() {
// Non-split position: unstake decrements once
let stake_amount = 100 * DECIMAL_FACTOR;
let mut total_locked_lp = 0u128;
// Stake with 6mo lock
total_locked_lp += stake_amount;
// Unstake: lock_duration >= SIX_MONTHS → decrement
total_locked_lp = total_locked_lp.saturating_sub(stake_amount);
assert_eq!(total_locked_lp, 0);
// No RedeemExpired for non-split (wLP doesn't exist)
// Single decrement ✓
}
#[test]
fn test_multiple_positions_locked_accounting() {
let mut total_locked_lp = 0u128;
// Position A: 100 LP, 6mo lock
total_locked_lp += 100 * DECIMAL_FACTOR;
// Position B: 200 LP, 1yr lock
total_locked_lp += 200 * DECIMAL_FACTOR;
// Position C: 50 LP, 1mo lock (< 6mo, doesn't count)
// no increment
assert_eq!(total_locked_lp, 300 * DECIMAL_FACTOR);
// Split A, claim after expiry → decrement 100
total_locked_lp = total_locked_lp.saturating_sub(100 * DECIMAL_FACTOR);
assert_eq!(total_locked_lp, 200 * DECIMAL_FACTOR);
// Unstake B → decrement 200
total_locked_lp = total_locked_lp.saturating_sub(200 * DECIMAL_FACTOR);
assert_eq!(total_locked_lp, 0);
// RedeemExpired A's wLP → NO decrement (already counted in claim)
assert_eq!(total_locked_lp, 0);
}
// ══════════════════════════════════════════════════════════════
// System invariants
// ══════════════════════════════════════════════════════════════
#[test]
fn test_invariant_total_weighted_stake_tracks_positions() {
// total_weighted_stake must equal sum of all active position weights
let mut total_weighted = 0u128;
let positions: Vec<(u128, u128)> = vec![
(100 * DECIMAL_FACTOR, 300), // 100 LP, 3x
(50 * DECIMAL_FACTOR, 250), // 50 LP, 2.5x
(200 * DECIMAL_FACTOR, 100), // 200 LP, 1x
];
// Stake all
for (amount, mult) in &positions {
let weighted = amount * mult / MULTIPLIER_BASE;
total_weighted += weighted;
}
let expected = (100 * DECIMAL_FACTOR * 300 / 100)
+ (50 * DECIMAL_FACTOR * 250 / 100)
+ (200 * DECIMAL_FACTOR * 100 / 100);
assert_eq!(total_weighted, expected);
// Unstake first position
let (amount, mult) = positions[0];
let weighted = amount * mult / MULTIPLIER_BASE;
total_weighted = total_weighted.saturating_sub(weighted);
let expected_after = (50 * DECIMAL_FACTOR * 250 / 100)
+ (200 * DECIMAL_FACTOR * 100 / 100);
assert_eq!(total_weighted, expected_after);
// Unstake all remaining
for (amount, mult) in &positions[1..] {
let weighted = amount * mult / MULTIPLIER_BASE;
total_weighted = total_weighted.saturating_sub(weighted);
}
assert_eq!(total_weighted, 0, "all unstaked → total must be 0");
}
#[test]
fn test_invariant_total_locked_lp_tracks_long_locks() {
// total_locked_lp must equal sum of LP from positions with lock >= 6 months
let mut total_locked = 0u128;
// Stake with various locks
let stakes: Vec<(u128, u64)> = vec![
(100 * DECIMAL_FACTOR, YEAR), // counts (≥ 6mo)
(50 * DECIMAL_FACTOR, SIX_MONTHS), // counts (= 6mo)
(200 * DECIMAL_FACTOR, THREE_MONTHS), // doesn't count (< 6mo)
(75 * DECIMAL_FACTOR, WEEK), // doesn't count
(300 * DECIMAL_FACTOR, 0), // doesn't count (no lock)
];
for (amount, lock) in &stakes {
if *lock >= SIX_MONTHS {
total_locked += amount;
}
}
assert_eq!(total_locked, 150 * DECIMAL_FACTOR, "only 100+50 LP should count");
// Unstake the 100 LP year-lock
total_locked = total_locked.saturating_sub(100 * DECIMAL_FACTOR);
assert_eq!(total_locked, 50 * DECIMAL_FACTOR);
// Claim after expiry for 50 LP six-month-lock (auto-unstake)
total_locked = total_locked.saturating_sub(50 * DECIMAL_FACTOR);
assert_eq!(total_locked, 0);
}
#[test]
fn test_invariant_mint_never_exceeds_pool() {
// Minting from pool: remaining -= amount. Must never go below 0.
let mut staking_remaining = STAKING_EMISSION_POOL;
let mut bonding_remaining = BONDING_EMISSION_POOL;
// Simulate epoch 0 full emission
let staking_epoch0 = STAKING_EMISSION_RATE * HALVING_INTERVAL as u128;
let bonding_epoch0 = BONDING_EMISSION_RATE * HALVING_INTERVAL as u128;
assert!(staking_epoch0 <= staking_remaining, "epoch 0 staking fits in pool");
assert!(bonding_epoch0 <= bonding_remaining, "epoch 0 bonding fits in pool");
staking_remaining -= staking_epoch0;
bonding_remaining -= bonding_epoch0;
// Epoch 1 (halved)
let staking_epoch1 = (STAKING_EMISSION_RATE >> 1) * HALVING_INTERVAL as u128;
let bonding_epoch1 = (BONDING_EMISSION_RATE >> 1) * HALVING_INTERVAL as u128;
assert!(staking_epoch1 <= staking_remaining);
assert!(bonding_epoch1 <= bonding_remaining);
staking_remaining -= staking_epoch1;
bonding_remaining -= bonding_epoch1;
// After 2 epochs: 75% of pool used
let staking_used_pct = (STAKING_EMISSION_POOL - staking_remaining) * 100 / STAKING_EMISSION_POOL;
let bonding_used_pct = (BONDING_EMISSION_POOL - bonding_remaining) * 100 / BONDING_EMISSION_POOL;
assert_eq!(staking_used_pct, 75);
assert_eq!(bonding_used_pct, 75);
// Sum all epochs until pool exhausted
let mut total_staking = 0u128;
let mut total_bonding = 0u128;
for epoch in 0..64u128 {
let s = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch) * HALVING_INTERVAL as u128;
let b = get_emission_rate_for_epoch(BONDING_EMISSION_RATE, epoch) * HALVING_INTERVAL as u128;
total_staking += s;
total_bonding += b;
}
assert!(total_staking <= STAKING_EMISSION_POOL,
"total staking emission {} must not exceed pool {}", total_staking, STAKING_EMISSION_POOL);
assert!(total_bonding <= BONDING_EMISSION_POOL,
"total bonding emission {} must not exceed pool {}", total_bonding, BONDING_EMISSION_POOL);
}
#[test]
fn test_invariant_wlp_supply_equals_split_minus_burned() {
// wLP supply = sum(split deposits) - sum(merged + unstaked_split + redeemed_expired)
let mut wlp_supply = 0u128;
// Split position A (100 LP)
wlp_supply += 100 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 100 * DECIMAL_FACTOR);
// Split position B (50 LP)
wlp_supply += 50 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 150 * DECIMAL_FACTOR);
// Merge position A (burn 100 wLP)
wlp_supply -= 100 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 50 * DECIMAL_FACTOR);
// Unstake split position B (burn 50 wLP)
wlp_supply -= 50 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 0);
// After all operations: wLP supply must be 0
assert_eq!(wlp_supply, 0, "all wLP burned → supply must be 0");
}
#[test]
fn test_invariant_wlp_supply_with_redeem_expired() {
let mut wlp_supply = 0u128;
// Split 3 positions
wlp_supply += 100 * DECIMAL_FACTOR;
wlp_supply += 200 * DECIMAL_FACTOR;
wlp_supply += 50 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 350 * DECIMAL_FACTOR);
// After expiry: redeem 150 wLP via RedeemExpired
wlp_supply -= 150 * DECIMAL_FACTOR;
// Claim NFTs (no wLP change for split positions)
// Remaining 200 wLP redeemed
wlp_supply -= 200 * DECIMAL_FACTOR;
assert_eq!(wlp_supply, 0);
}
#[test]
fn test_invariant_floor_never_negative() {
// floor = treasury / supply. Both u128, both >= 0. Floor always >= 0.
for (treasury, supply) in [(0u128, 0u128), (0, 100), (100, 0), (100, 100)] {
let floor = if supply > 0 { treasury * DECIMAL_FACTOR / supply } else { 0 };
assert!(floor <= u128::MAX); // trivially true but documents intent
}
}
#[test]
fn test_invariant_redemption_preserves_proportional_share() {
// After any number of redemptions, each remaining holder has same % of treasury
let mut treasury = 10_000 * DECIMAL_FACTOR;
let mut supply = 100_000 * DECIMAL_FACTOR;
// 10 sequential redemptions of 5% supply each
for _ in 0..10 {
let redeem = supply * 5 / 100;
let lp_back = redemption_value(redeem, treasury, supply, 0);
treasury -= lp_back;
supply -= redeem;
}
// Floor should be unchanged (proportional)
let floor_after = redemption_rate(treasury, supply);
let floor_before = redemption_rate(10_000 * DECIMAL_FACTOR, 100_000 * DECIMAL_FACTOR);
assert_eq!(floor_after, floor_before,
"floor must be invariant after proportional redemptions");
}
#[test]
fn test_invariant_redemption_with_fee_always_increases_floor() {
let mut treasury = 10_000 * DECIMAL_FACTOR;
let mut supply = 100_000 * DECIMAL_FACTOR;
let fee_bps = 100u128; // 1%
let floor_before = redemption_rate(treasury, supply);
// 5 sequential redemptions with fee
for _ in 0..5 {
let redeem = supply * 10 / 100; // 10% each time
let lp_returned = redemption_value(redeem, treasury, supply, fee_bps);
// Fee stays in treasury
let gross = redeem * redemption_rate(treasury, supply) / DECIMAL_FACTOR;
let fee_lp = gross - lp_returned;
treasury -= lp_returned; // user gets this
// fee_lp stays (already in treasury, just not sent out)
supply -= redeem; // FIRE burned
}
let floor_after = redemption_rate(treasury, supply);
assert!(floor_after > floor_before,
"floor must increase after redemptions with fee: {} → {}", floor_before, floor_after);
}
#[test]
fn test_invariant_total_emission_bounded_by_max_supply() {
// Total staking + bonding emission across all epochs must not exceed MAX_SUPPLY
let mut total = 0u128;
for epoch in 0..64u128 {
let staking = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch);
let bonding = get_emission_rate_for_epoch(BONDING_EMISSION_RATE, epoch);
total += (staking + bonding) * HALVING_INTERVAL as u128;
}
assert!(total <= MAX_SUPPLY,
"total emission {} must not exceed MAX_SUPPLY {}", total, MAX_SUPPLY);
// Should be very close (within 1 FIRE of rounding)
let diff = MAX_SUPPLY - total;
assert!(diff < DECIMAL_FACTOR,
"emission should be within 1 FIRE of MAX_SUPPLY, diff={}", diff);
}
#[test]
fn test_invariant_bonding_capacity_bounded_per_epoch() {
// Total FIRE bondable in one epoch = rate × HALVING_INTERVAL
// Must equal half of remaining bonding pool for that epoch
let epoch0_cap = BONDING_EMISSION_RATE * HALVING_INTERVAL as u128;
assert_eq!(epoch0_cap, BONDING_EMISSION_POOL / 2,
"epoch 0 bond capacity = half of total bonding pool");
let epoch1_cap = (BONDING_EMISSION_RATE >> 1) * HALVING_INTERVAL as u128;
assert_eq!(epoch1_cap, BONDING_EMISSION_POOL / 4,
"epoch 1 bond capacity = quarter of total bonding pool");
}
#[test]
fn test_invariant_locked_lp_never_exceeds_total_staked() {
// total_locked_lp (≥6mo only) must be ≤ total LP ever staked
let mut total_staked_lp = 0u128;
let mut total_locked_lp = 0u128;
// Stake 100 LP with year lock
total_staked_lp += 100 * DECIMAL_FACTOR;
total_locked_lp += 100 * DECIMAL_FACTOR;
assert!(total_locked_lp <= total_staked_lp);
// Stake 200 LP with no lock
total_staked_lp += 200 * DECIMAL_FACTOR;
// locked doesn't change
assert!(total_locked_lp <= total_staked_lp);
// Stake 50 LP with 6mo lock
total_staked_lp += 50 * DECIMAL_FACTOR;
total_locked_lp += 50 * DECIMAL_FACTOR;
assert!(total_locked_lp <= total_staked_lp);
// Always: locked ≤ total
assert!(total_locked_lp <= total_staked_lp);
}
#[test]
fn test_bonding_total_lp_accumulates_across_epochs() {
let mut sim = BondingSim::new(0);
let _ = sim.bond(100 * DECIMAL_FACTOR, 1000, 50000);
assert_eq!(sim.total_bonded_lp, 1000);
sim.check_epoch(HALVING_INTERVAL + 1000);
assert_eq!(sim.total_bonded_fire, 0);
assert_eq!(sim.total_bonded_lp, 1000);
let _ = sim.bond(50 * DECIMAL_FACTOR, 500, HALVING_INTERVAL + 2000);
assert_eq!(sim.total_bonded_lp, 1500);
}
// ── Target position selection (opcode parameter contracts) ────
/// Simulates the authenticate_position logic used in staking/bonding.
/// target = (0,0) → find first registered; otherwise match exact ID.
fn authenticate_position_sim(
incoming: &[(u128, u128, u128)], // (block, tx, value)
registered: &[(u128, u128)],
target_block: u128,
target_tx: u128,
) -> Option<(u128, u128)> {
let is_registered = |b: u128, t: u128| -> bool {
registered.iter().any(|(rb, rt)| *rb == b && *rt == t)
};
if target_block == 0 && target_tx == 0 {
incoming.iter()
.find(|(b, t, v)| *v >= 1 && is_registered(*b, *t))
.map(|(b, t, _)| (*b, *t))
} else {
incoming.iter()
.find(|(b, t, v)| *v >= 1 && *b == target_block && *t == target_tx && is_registered(*b, *t))
.map(|(b, t, _)| (*b, *t))
}
}
#[test]
fn test_target_position_zero_finds_first() {
let incoming = vec![(2, 100, 1), (2, 200, 1), (2, 300, 1)];
let registered = vec![(2, 100), (2, 200), (2, 300)];
let result = authenticate_position_sim(&incoming, &registered, 0, 0);
assert_eq!(result, Some((2, 100))); // first registered
}
#[test]
fn test_target_position_selects_specific() {
let incoming = vec![(2, 100, 1), (2, 200, 1), (2, 300, 1)];
let registered = vec![(2, 100), (2, 200), (2, 300)];
let result = authenticate_position_sim(&incoming, &registered, 2, 200);
assert_eq!(result, Some((2, 200))); // specific match
}
#[test]
fn test_target_position_rejects_unregistered() {
let incoming = vec![(2, 100, 1), (2, 999, 1)];
let registered = vec![(2, 100)];
let result = authenticate_position_sim(&incoming, &registered, 2, 999);
assert_eq!(result, None); // 999 not registered
}
#[test]
fn test_target_position_rejects_not_in_incoming() {
let incoming = vec![(2, 100, 1)];
let registered = vec![(2, 100), (2, 200)];
let result = authenticate_position_sim(&incoming, &registered, 2, 200);
assert_eq!(result, None); // 200 registered but not in incoming
}
#[test]
fn test_target_position_skips_zero_value() {
let incoming = vec![(2, 100, 0), (2, 200, 1)];
let registered = vec![(2, 100), (2, 200)];
let result = authenticate_position_sim(&incoming, &registered, 0, 0);
assert_eq!(result, Some((2, 200))); // skips 100 (value=0)
}
// ── Token return / change flow simulation ────────────────────
/// Simulates the token return pattern used across all FIRE handlers.
/// Given incoming transfers, consumed token ID + amount, returns what
/// the response should contain.
fn simulate_token_return(
incoming: &[(u128, u128, u128)], // (block, tx, value)
consumed_id: (u128, u128), // token to consume
consume_amount: u128,
) -> Vec<(u128, u128, u128)> {
let mut response = Vec::new();
for &(b, t, v) in incoming {
if b == consumed_id.0 && t == consumed_id.1 {
let change = v.saturating_sub(consume_amount);
if change > 0 {
response.push((b, t, change));
}
} else {
response.push((b, t, v));
}
}
response
}
#[test]
fn test_return_exact_consumption_no_change() {
// Stake exactly all LP — no LP change, non-LP forwarded
let incoming = vec![(2, 3, 1000), (4, 256, 50)]; // LP + FIRE
let result = simulate_token_return(&incoming, (2, 3), 1000);
assert_eq!(result, vec![(4, 256, 50)]); // only FIRE returned
}
#[test]
fn test_return_partial_consumption_with_change() {
// Bond 400 LP out of 1000 — 600 change + non-LP forwarded
let incoming = vec![(2, 3, 1000), (32, 0, 200)]; // LP + frBTC
let result = simulate_token_return(&incoming, (2, 3), 400);
assert_eq!(result, vec![(2, 3, 600), (32, 0, 200)]);
}
#[test]
fn test_return_all_non_matching_forwarded() {
// Burn FIRE — all non-FIRE forwarded
let incoming = vec![(4, 256, 500), (2, 0, 100), (32, 0, 50)];
let result = simulate_token_return(&incoming, (4, 256), 500);
assert_eq!(result, vec![(2, 0, 100), (32, 0, 50)]);
}
#[test]
fn test_return_no_tokens_stuck() {
// Send 3 different tokens, consume one partially
let incoming = vec![(2, 3, 1000), (2, 6, 500), (4, 256, 200)];
let result = simulate_token_return(&incoming, (2, 3), 300);
// All 3 accounted for: LP change + wLP + FIRE
assert_eq!(result.len(), 3);
assert_eq!(result[0], (2, 3, 700)); // LP change
assert_eq!(result[1], (2, 6, 500)); // wLP forwarded
assert_eq!(result[2], (4, 256, 200)); // FIRE forwarded
}
#[test]
fn test_return_zero_consumption_all_forwarded() {
// ClaimRewards with zero claimable — everything returned
let incoming = vec![(2, 100, 1), (2, 0, 50)]; // NFT + DIESEL
let result = simulate_token_return(&incoming, (99, 99), 0); // consume nothing
assert_eq!(result, incoming);
}
#[test]
fn test_return_overconsumption_saturates() {
// Try to consume more than available — saturating_sub gives 0, no change
let incoming = vec![(2, 3, 100)];
let result = simulate_token_return(&incoming, (2, 3), 999);
assert_eq!(result, vec![]); // consumed all, no change
}
// ── ACTIVATION_BLOCK + epoch boundary edge cases ─────────────
#[test]
fn test_activation_block_value() {
assert_eq!(ACTIVATION_BLOCK, 950_420);
// Must be before Bitcoin halving #5
assert!(ACTIVATION_BLOCK < 1_050_000);
}
#[test]
fn test_activation_block_epoch() {
// ACTIVATION_BLOCK falls in absolute epoch 9 (950420 / 105000 = 9)
assert_eq!(absolute_epoch(ACTIVATION_BLOCK), 9);
}
#[test]
fn test_first_epoch_shortened() {
// First epoch: [ACTIVATION_BLOCK, next_boundary - 1]
let epoch_9_end = (9 + 1) * HALVING_INTERVAL - 1; // 1,049,999
let first_epoch_blocks = epoch_9_end as u64 - ACTIVATION_BLOCK;
assert_eq!(first_epoch_blocks, 99_579); // shorter than full 105,000
assert!(first_epoch_blocks < HALVING_INTERVAL);
}
#[test]
fn test_first_halving_at_bitcoin_halving() {
// Epoch 10 starts at block 1,050,000 = Bitcoin halving #5
let epoch_10_start = 10 * HALVING_INTERVAL; // 1,050,000
assert_eq!(epoch_10_start, 1_050_000);
assert_eq!(epoch_10_start, 5 * BITCOIN_HALVING);
}
#[test]
fn test_epoch_before_activation() {
// calculate_epoch from activation to before activation = 0
assert_eq!(calculate_epoch(ACTIVATION_BLOCK, ACTIVATION_BLOCK), 0);
assert_eq!(calculate_epoch(ACTIVATION_BLOCK, ACTIVATION_BLOCK + 1), 0);
}
#[test]
fn test_epoch_at_first_halving() {
// At block 1,050,000 we cross into epoch 10 → 1 halving from epoch 9
assert_eq!(calculate_epoch(ACTIVATION_BLOCK, 1_050_000), 1);
}
#[test]
fn test_epoch_at_second_halving() {
// 1,155,000 = epoch 11 → 2 halvings from epoch 9
assert_eq!(calculate_epoch(ACTIVATION_BLOCK, 1_155_000), 2);
}
#[test]
fn test_emission_rate_at_activation() {
// Epoch 0 (from FIRE perspective): full rate
let epoch = calculate_epoch(ACTIVATION_BLOCK, ACTIVATION_BLOCK);
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch), 850_000_000);
assert_eq!(get_emission_rate_for_epoch(BONDING_EMISSION_RATE, epoch), 150_000_000);
}
#[test]
fn test_emission_rate_after_first_halving() {
let epoch = calculate_epoch(ACTIVATION_BLOCK, 1_050_000);
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch), 425_000_000);
assert_eq!(get_emission_rate_for_epoch(BONDING_EMISSION_RATE, epoch), 75_000_000);
}
#[test]
fn test_emission_rate_after_second_halving() {
let epoch = calculate_epoch(ACTIVATION_BLOCK, 1_155_000);
assert_eq!(get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch), 212_500_000);
}
#[test]
fn test_expiry_first_epoch() {
// First epoch expiry = 1,049,999
let abs_epoch = absolute_epoch(ACTIVATION_BLOCK); // 9
let expiry = (abs_epoch as u64 + 1) * HALVING_INTERVAL - 1;
assert_eq!(expiry, 1_049_999);
}
#[test]
fn test_expiry_second_epoch() {
let expiry = (10 + 1) * HALVING_INTERVAL - 1; // epoch 10 end
assert_eq!(expiry, 1_154_999);
}
#[test]
fn test_first_epoch_emission_total() {
// First epoch is shortened: 99,579 blocks at epoch 0 rate
let blocks = (1_050_000 - ACTIVATION_BLOCK) as u128;
let staking_emission = STAKING_EMISSION_RATE * blocks;
let bonding_emission = BONDING_EMISSION_RATE * blocks;
// Should be less than full epoch (105,000 blocks)
let full_staking = STAKING_EMISSION_RATE * HALVING_INTERVAL as u128;
assert!(staking_emission < full_staking);
// But close to 95% of full
assert!(staking_emission * 100 / full_staking >= 94);
// Total first epoch emission
let total = staking_emission + bonding_emission;
assert!(total > 0);
}
#[test]
fn test_ten_halvings_from_activation() {
// After 10 halvings: rate = initial >> 10 ≈ 0
let epoch_10 = calculate_epoch(ACTIVATION_BLOCK, ACTIVATION_BLOCK as u64 + 10 * HALVING_INTERVAL);
assert_eq!(epoch_10, 10);
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch_10);
assert_eq!(rate, 850_000_000 / 1024); // 830,078
assert!(rate > 0); // still emitting
}
#[test]
fn test_thirty_halvings_emission_zero() {
// After 30 halvings: rate = 850M >> 30 = 0
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 30);
assert_eq!(rate, 0);
}
#[test]
fn test_all_bitcoin_halvings_align() {
// Every Bitcoin halving (210k multiple) should be an even FIRE epoch
for btc in [210_000u64, 420_000, 630_000, 840_000, 1_050_000, 1_260_000] {
let fire_epoch = absolute_epoch(btc);
assert_eq!(fire_epoch % 2, 0, "BTC halving {} = FIRE epoch {} (not even)", btc, fire_epoch);
}
}
#[test]
fn test_activation_not_on_boundary() {
// ACTIVATION_BLOCK is NOT on a halving boundary
assert_ne!(ACTIVATION_BLOCK % HALVING_INTERVAL, 0);
// But the NEXT boundary after activation IS Bitcoin halving
let next_boundary = (absolute_epoch(ACTIVATION_BLOCK) as u64 + 1) * HALVING_INTERVAL;
assert_eq!(next_boundary, 1_050_000);
}
}

Verified Source