Source – Alkane 2:86620 — SUBFROST Explorer

src/tests/fire_e2e.rs14,485 B

//! # FIRE End-to-End Tests
//!
//! Complete integration tests for the FIRE system:
//! 1. Setup foundation (DIESEL, frBTC, AMM, LP pool)
//! 2. Deploy all FIRE contracts
//! 3. Initialize system with real LP tokens
//! 4. Stake LP and earn FIRE
//! 5. Bond LP for discounted FIRE
//! 6. Redeem FIRE for backing
//! 7. Community distribution via merkle claims
use crate::tests::helpers::{
clear_test_environment, index_block, fire_token_id, fire_staking_id, fire_treasury_id,
fire_bonding_id, fire_redemption_id,
FIRE_TOKEN_TX, FIRE_STAKING_TX, FIRE_TREASURY_TX, FIRE_BONDING_TX,
FIRE_REDEMPTION_TX,
create_deployment_block, create_operation_block,
init_with_multiple_cellpacks_with_tx,
FR_BTC_ID,
};
use crate::tests::fire_foundation::AUTH_TOKEN_FACTORY_ID;
use crate::tests::foundation::{setup_foundation, FoundationState};
use crate::tests::vendor::{
get_fire_token_wasm_bytes, get_fire_staking_wasm_bytes, get_fire_treasury_wasm_bytes,
get_fire_bonding_wasm_bytes, get_fire_redemption_wasm_bytes,
};
use crate::test_log;
use alkanes_support::cellpack::Cellpack;
use alkanes_support::id::AlkaneId;
use anyhow::Result;
use bitcoin::OutPoint;
use wasm_bindgen_test::wasm_bindgen_test;
/// Complete FIRE system deployment with foundation
#[derive(Debug, Clone)]
pub struct CompleteFireDeployment {
pub fire_token_id: AlkaneId,
pub fire_staking_id: AlkaneId,
pub fire_treasury_id: AlkaneId,
pub fire_bonding_id: AlkaneId,
pub fire_redemption_id: AlkaneId,
// fire-distributor removed (0% premine)
pub lp_token_id: AlkaneId,
pub lp_amount: u128,
pub lp_outpoint: OutPoint,
pub current_height: u32,
}
/// Deploy all FIRE contracts (without foundation)
pub fn deploy_fire_contracts(start_height: u32) -> Result<(u32, OutPoint)> {
use alkanes::precompiled::alkanes_std_auth_token_build;
test_log!("[FIRE E2E] Deploying FIRE contracts...");
let mut height = start_height;
// 0. Deploy auth token factory first (required for treasury, bonding, etc.)
test_log!("[FIRE E2E] Deploying auth token factory to [4, {}]...", AUTH_TOKEN_FACTORY_ID);
let auth_block = init_with_multiple_cellpacks_with_tx(
vec![alkanes_std_auth_token_build::get_bytes().to_vec()],
vec![Cellpack {
target: AlkaneId { block: 3, tx: AUTH_TOKEN_FACTORY_ID },
inputs: vec![100], // Auth token factory init marker
}],
);
index_block(&auth_block, height)?;
height += 1;
// 1. Deploy fire-token
test_log!("[FIRE E2E] Deploying fire-token to [4, {}]...", FIRE_TOKEN_TX);
let block = create_deployment_block(
height,
get_fire_token_wasm_bytes(),
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TOKEN_TX },
inputs: vec![],
},
);
index_block(&block, height)?;
height += 1;
// 2. Deploy fire-staking
test_log!("[FIRE E2E] Deploying fire-staking to [4, {}]...", FIRE_STAKING_TX);
let block = create_deployment_block(
height,
get_fire_staking_wasm_bytes(),
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_STAKING_TX },
inputs: vec![],
},
);
index_block(&block, height)?;
height += 1;
// 3. Deploy fire-treasury
test_log!("[FIRE E2E] Deploying fire-treasury to [4, {}]...", FIRE_TREASURY_TX);
let block = create_deployment_block(
height,
get_fire_treasury_wasm_bytes(),
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TREASURY_TX },
inputs: vec![],
},
);
index_block(&block, height)?;
height += 1;
// 4. Deploy fire-bonding
test_log!("[FIRE E2E] Deploying fire-bonding to [4, {}]...", FIRE_BONDING_TX);
let block = create_deployment_block(
height,
get_fire_bonding_wasm_bytes(),
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_BONDING_TX },
inputs: vec![],
},
);
index_block(&block, height)?;
height += 1;
// 5. Deploy fire-redemption
test_log!("[FIRE E2E] Deploying fire-redemption to [4, {}]...", FIRE_REDEMPTION_TX);
let block = create_deployment_block(
height,
get_fire_redemption_wasm_bytes(),
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_REDEMPTION_TX },
inputs: vec![],
},
);
index_block(&block, height)?;
height += 1;
// 6. fire-distributor removed (0% premine — nothing to distribute)
let last_outpoint = OutPoint {
txid: block.txdata[1].compute_txid(),
vout: 0,
};
test_log!("[FIRE E2E] All FIRE contracts deployed!");
Ok((height, last_outpoint))
}
/// Initialize the FIRE token with staking contract and treasury
pub fn initialize_fire_token(
height: u32,
_lp_token: AlkaneId,
) -> Result<(OutPoint, u32)> {
test_log!("[FIRE E2E] Initializing fire-token...");
// Initialize fire-token: opcode 0
// inputs: [staking_contract, treasury, treasury_amount, team_vesting, team_amount, emission_pool]
let init_block = create_operation_block(
height,
Cellpack {
target: fire_token_id(),
inputs: vec![
0, // Initialize opcode
fire_staking_id().block,
fire_staking_id().tx,
fire_treasury_id().block,
fire_treasury_id().tx,
105_000_000_000_000_000, // treasury_amount (1.05M FIRE with 8 decimals)
0, 0, // No team vesting contract
0, // team_amount = 0
63_000_000_000_000_000, // emission_pool (630K FIRE)
],
},
None,
);
index_block(&init_block, height)?;
let outpoint = OutPoint {
txid: init_block.txdata[1].compute_txid(),
vout: 0,
};
test_log!("[FIRE E2E] fire-token initialized");
Ok((outpoint, height + 1))
}
/// Initialize the FIRE staking contract
pub fn initialize_fire_staking(
height: u32,
lp_token: AlkaneId,
) -> Result<(OutPoint, u32)> {
test_log!("[FIRE E2E] Initializing fire-staking with LP token {:?}...", lp_token);
// Initialize fire-staking: opcode 0
// inputs: [lp_token, fire_token, position_template, wlp_template, start_block, expiry, halving_epoch]
let position_template = 0x106u128; // fire-position-token
let wlp_template = 0x108u128; // fire-series-token
let start_block = height as u128;
let expiry_height = start_block + 105_000 - 1;
let halving_epoch = 0u128;
let init_block = create_operation_block(
height,
Cellpack {
target: fire_staking_id(),
inputs: vec![
0, // Initialize opcode
lp_token.block,
lp_token.tx,
fire_token_id().block,
fire_token_id().tx,
position_template,
wlp_template,
start_block,
expiry_height,
halving_epoch,
],
},
None,
);
index_block(&init_block, height)?;
let outpoint = OutPoint {
txid: init_block.txdata[1].compute_txid(),
vout: 0,
};
test_log!("[FIRE E2E] fire-staking initialized");
Ok((outpoint, height + 1))
}
/// Initialize the FIRE treasury contract
pub fn initialize_fire_treasury(
height: u32,
lp_token: AlkaneId,
) -> Result<(OutPoint, u32)> {
test_log!("[FIRE E2E] Initializing fire-treasury...");
// Initialize fire-treasury: opcode 0
// inputs: [fire_token, diesel_lp_token, bonding_contract, redemption_contract]
let init_block = create_operation_block(
height,
Cellpack {
target: fire_treasury_id(),
inputs: vec![
0, // Initialize opcode
fire_token_id().block,
fire_token_id().tx,
lp_token.block, // diesel_lp_token
lp_token.tx,
fire_bonding_id().block,
fire_bonding_id().tx,
fire_redemption_id().block,
fire_redemption_id().tx,
],
},
None,
);
index_block(&init_block, height)?;
let outpoint = OutPoint {
txid: init_block.txdata[1].compute_txid(),
vout: 0,
};
test_log!("[FIRE E2E] fire-treasury initialized");
Ok((outpoint, height + 1))
}
/// Deploy and initialize complete FIRE system on top of foundation
pub fn deploy_complete_fire_system_with_foundation() -> Result<(CompleteFireDeployment, FoundationState)> {
test_log!("\n[FIRE E2E] ===== Starting Complete FIRE System Setup =====\n");
// 1. Setup foundation (DIESEL, frBTC, AMM, LP pool)
let foundation = setup_foundation(880_000)?;
// 2. Deploy FIRE contracts
let (mut height, _) = deploy_fire_contracts(foundation.current_height)?;
// 3. Initialize contracts
let (_, h) = initialize_fire_token(height, foundation.lp_token_id)?;
height = h;
let (_, h) = initialize_fire_staking(height, foundation.lp_token_id)?;
height = h;
let (_, h) = initialize_fire_treasury(height, foundation.lp_token_id)?;
height = h;
test_log!("\n[FIRE E2E] ===== FIRE System Setup Complete =====\n");
let deployment = CompleteFireDeployment {
fire_token_id: fire_token_id(),
fire_staking_id: fire_staking_id(),
fire_treasury_id: fire_treasury_id(),
fire_bonding_id: fire_bonding_id(),
fire_redemption_id: fire_redemption_id(),
lp_token_id: foundation.lp_token_id,
lp_amount: foundation.lp_amount,
lp_outpoint: foundation.lp_outpoint,
current_height: height,
};
Ok((deployment, foundation))
}
// ============ Tests ============
#[wasm_bindgen_test]
fn test_complete_fire_deployment() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: Complete FIRE System Deployment (without foundation)");
test_log!("======================================================================\n");
let start_height = 880_000;
let (height, _) = deploy_fire_contracts(start_height)?;
test_log!("\nComplete FIRE system deployed:");
test_log!(" fire-token: {:?}", fire_token_id());
test_log!(" fire-staking: {:?}", fire_staking_id());
test_log!(" fire-treasury: {:?}", fire_treasury_id());
test_log!(" fire-bonding: {:?}", fire_bonding_id());
test_log!(" fire-redemption: {:?}", fire_redemption_id());
// fire-distributor removed (0% premine)
test_log!(" Final height: {}", height);
Ok(())
}
#[wasm_bindgen_test]
fn test_fire_with_real_lp_tokens() -> Result<()> {
test_log!("\n======================================================================");
test_log!("TEST: FIRE System with Real LP Tokens");
test_log!("======================================================================\n");
let (deployment, foundation) = deploy_complete_fire_system_with_foundation()?;
test_log!("\nFIRE system deployed with real LP tokens:");
test_log!(" fire-token: {:?}", deployment.fire_token_id);
test_log!(" fire-staking: {:?}", deployment.fire_staking_id);
test_log!(" fire-treasury: {:?}", deployment.fire_treasury_id);
test_log!(" LP Token: {:?}", deployment.lp_token_id);
test_log!(" LP Amount: {}", deployment.lp_amount);
// Verify LP tokens exist
assert!(deployment.lp_amount > 0, "LP tokens not minted");
// Verify foundation tokens remain
test_log!("\nRemaining foundation tokens:");
test_log!(" DIESEL: {}", foundation.diesel_amount);
test_log!(" frBTC: {}", foundation.frbtc_amount);
Ok(())
}
#[wasm_bindgen_test]
fn test_fire_tokenomics_constants() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: FIRE Tokenomics Constants Verification");
test_log!("======================================================================\n");
use fire_support::*;
// Verify supply distribution (80/20 split, 0% premine)
assert_eq!(
STAKING_EMISSION_POOL + BONDING_EMISSION_POOL,
MAX_SUPPLY,
"Staking + bonding pools should equal max supply"
);
test_log!(" Max Supply: {} FIRE", MAX_SUPPLY / DECIMAL_FACTOR);
test_log!(" Staking Pool: {} FIRE (80%)", STAKING_EMISSION_POOL / DECIMAL_FACTOR);
test_log!(" Bonding Pool: {} FIRE (20%)", BONDING_EMISSION_POOL / DECIMAL_FACTOR);
// Verify emission rates
test_log!("\n Emission Schedule:");
test_log!(" Epoch 0 staking: {} units/block (~{} FIRE/day)",
get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 0),
get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 0) * 144 / DECIMAL_FACTOR
);
test_log!(" Epoch 1 staking: {} units/block (halved)", get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 1));
test_log!(" Epoch 2 staking: {} units/block (quartered)", get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 2));
// Verify time constants (blocks, not seconds)
test_log!("\n Time Constants (blocks):");
test_log!(" Week: {} blocks", WEEK);
test_log!(" Month: {} blocks", MONTH);
test_log!(" Year: {} blocks", YEAR);
test_log!(" Halving Interval: {} blocks (2 years)", TWO_YEARS);
test_log!("\nAll tokenomics constants verified");
Ok(())
}
#[wasm_bindgen_test]
fn test_emission_halving_schedule() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: Emission Halving Schedule");
test_log!("======================================================================\n");
use fire_support::*;
let initial_rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, 0);
for epoch in 0..10 {
let rate = get_emission_rate_for_epoch(STAKING_EMISSION_RATE, epoch);
let expected = initial_rate >> epoch;
assert_eq!(rate, expected, "Epoch {} rate should be halved", epoch);
let daily_fire = rate * 144 / DECIMAL_FACTOR;
test_log!(" Epoch {} (year {}): {} FIRE/day", epoch, epoch * 2, daily_fire);
}
test_log!("\nHalving schedule verified");
Ok(())
}

Verified Source