Source – Alkane 2:87447 — SUBFROST Explorer

src/tests/fire_foundation.rs10,288 B

//! # FIRE Foundation Tests
//!
//! Tests for deploying and initializing the FIRE token system:
//! 1. Deploy fire-token contract
//! 2. Deploy fire-staking contract
//! 3. Deploy fire-treasury contract
//! 4. Initialize with correct parameters
//! 5. Verify token minting and staking works
use crate::tests::helpers::{
clear_test_environment, create_deployment_block, create_operation_block,
index_block, fire_token_id, fire_staking_id,
fire_treasury_id, FIRE_TOKEN_TX, FIRE_STAKING_TX, FIRE_TREASURY_TX,
};
use crate::tests::vendor::{
get_fire_token_wasm_bytes, get_fire_staking_wasm_bytes, get_fire_treasury_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;
/// FIRE system deployment structure
#[derive(Debug, Clone)]
pub struct FireDeployment {
pub fire_token_id: AlkaneId,
pub fire_staking_id: AlkaneId,
pub fire_treasury_id: AlkaneId,
pub start_height: u32,
pub current_height: u32,
}
/// Auth token factory ID (required for treasury)
pub const AUTH_TOKEN_FACTORY_ID: u128 = 0xffed; // 65517
/// Deploy the core FIRE contracts (bytecode only, no initialization)
pub fn deploy_fire_core(start_height: u32) -> Result<FireDeployment> {
use crate::tests::helpers::init_with_multiple_cellpacks_with_tx;
use alkanes::precompiled::alkanes_std_auth_token_build;
test_log!("[FIRE] Deploying FIRE core contracts starting at height {}", start_height);
let mut height = start_height;
// 0. Deploy auth token factory first (required for treasury)
test_log!("[FIRE] 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 (bytecode only)
test_log!("[FIRE] Deploying fire-token to [4, {}]", FIRE_TOKEN_TX);
let fire_token_wasm = get_fire_token_wasm_bytes();
let deploy_token_block = create_deployment_block(
height,
fire_token_wasm,
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TOKEN_TX },
inputs: vec![], // Empty - just deploy bytecode, initialize later
},
);
index_block(&deploy_token_block, height)?;
height += 1;
// 2. Deploy fire-staking (bytecode only)
test_log!("[FIRE] Deploying fire-staking to [4, {}]", FIRE_STAKING_TX);
let fire_staking_wasm = get_fire_staking_wasm_bytes();
let deploy_staking_block = create_deployment_block(
height,
fire_staking_wasm,
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_STAKING_TX },
inputs: vec![], // Empty - just deploy bytecode, initialize later
},
);
index_block(&deploy_staking_block, height)?;
height += 1;
// 3. Deploy fire-treasury (bytecode only)
test_log!("[FIRE] Deploying fire-treasury to [4, {}]", FIRE_TREASURY_TX);
let fire_treasury_wasm = get_fire_treasury_wasm_bytes();
let deploy_treasury_block = create_deployment_block(
height,
fire_treasury_wasm,
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TREASURY_TX },
inputs: vec![], // Empty - just deploy bytecode, initialize later
},
);
index_block(&deploy_treasury_block, height)?;
height += 1;
test_log!("[FIRE] Core contracts deployed (bytecode only)");
Ok(FireDeployment {
fire_token_id: fire_token_id(),
fire_staking_id: fire_staking_id(),
fire_treasury_id: fire_treasury_id(),
start_height,
current_height: height,
})
}
/// Initialize the FIRE token with staking contract and treasury
pub fn initialize_fire_token(
deployment: &FireDeployment,
_lp_token: AlkaneId,
) -> Result<(OutPoint, u32)> {
test_log!("[FIRE] Initializing fire-token...");
let mut height = deployment.current_height;
// Initialize fire-token: opcode 0
// inputs: [staking_contract, treasury, treasury_amount, team_vesting (optional), team_amount, emission_pool]
let init_block = create_operation_block(
height,
Cellpack {
target: deployment.fire_token_id,
inputs: vec![
0, // Initialize opcode
deployment.fire_staking_id.block,
deployment.fire_staking_id.tx,
deployment.fire_treasury_id.block,
deployment.fire_treasury_id.tx,
105_000_000_000_000_000, // treasury_amount (1.05M FIRE with 8 decimals)
0, 0, // No team vesting contract (placeholder)
0, // team_amount = 0 (handled separately)
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,
};
height += 1;
test_log!("[FIRE] fire-token initialized at {:?}", outpoint);
Ok((outpoint, height))
}
/// Initialize the FIRE staking contract
pub fn initialize_fire_staking(
deployment: &FireDeployment,
lp_token: AlkaneId,
height: u32,
) -> Result<(OutPoint, u32)> {
test_log!("[FIRE] Initializing fire-staking with LP token {:?}...", lp_token);
let mut height = height;
// 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; // HALVING_INTERVAL - 1
let halving_epoch = 0u128;
let init_block = create_operation_block(
height,
Cellpack {
target: deployment.fire_staking_id,
inputs: vec![
0, // Initialize opcode
lp_token.block,
lp_token.tx,
deployment.fire_token_id.block,
deployment.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,
};
height += 1;
test_log!("[FIRE] fire-staking initialized at {:?}", outpoint);
Ok((outpoint, height))
}
#[wasm_bindgen_test]
fn test_fire_deployment() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: FIRE Contract Deployment");
test_log!("======================================================================\n");
let start_height = 880_000;
// Deploy core contracts
let deployment = deploy_fire_core(start_height)?;
test_log!("\nDeployment complete:");
test_log!(" fire-token: {:?}", deployment.fire_token_id);
test_log!(" fire-staking: {:?}", deployment.fire_staking_id);
test_log!(" fire-treasury: {:?}", deployment.fire_treasury_id);
Ok(())
}
#[wasm_bindgen_test]
fn test_fire_deployment_with_trace() -> Result<()> {
use crate::tests::helpers::Tracer;
use crate::tests::vendor::get_fire_token_wasm_bytes;
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: FIRE Contract Deployment WITH TRACE");
test_log!("======================================================================\n");
let height = 880_000;
// Deploy just fire-token with tracing
test_log!("[TRACE] Deploying fire-token to [4, {}]", FIRE_TOKEN_TX);
let fire_token_wasm = get_fire_token_wasm_bytes();
test_log!("[TRACE] WASM size: {} bytes", fire_token_wasm.len());
let deploy_block = create_deployment_block(
height,
fire_token_wasm,
Cellpack {
target: AlkaneId { block: 3, tx: FIRE_TOKEN_TX },
inputs: vec![], // No initialization during deployment
},
);
// Trace the deployment
let tracer = Tracer::new("fire-token deployment");
tracer.index_and_trace(&deploy_block, height)?;
test_log!("\n[TRACE] Deployment indexed, checking traces...");
// Check if we can get trace data for the deployment tx
let deploy_txid = deploy_block.txdata[1].compute_txid();
for vout in 0..5u32 {
let outpoint = OutPoint { txid: deploy_txid, vout };
if let Ok(trace_data) = alkanes::view::trace(&outpoint) {
if !trace_data.is_empty() {
test_log!("[TRACE] Found trace at vout {}: {} bytes", vout, trace_data.len());
}
}
}
Ok(())
}
#[wasm_bindgen_test]
fn test_fire_initialization() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("🧪 TEST: FIRE System Initialization");
test_log!("======================================================================\n");
let start_height = 880_000;
// Deploy core contracts
let deployment = deploy_fire_core(start_height)?;
// For testing, use DIESEL/frBTC LP token (would be a real LP token in production)
// Using a placeholder LP token ID
let lp_token = AlkaneId { block: 4, tx: 0x200 };
// Initialize fire-token
let (token_outpoint, height) = initialize_fire_token(&deployment, lp_token)?;
// Initialize fire-staking
let (staking_outpoint, _height) = initialize_fire_staking(&deployment, lp_token, height)?;
test_log!("\n✅ Initialization complete:");
test_log!(" fire-token initialized at: {:?}", token_outpoint);
test_log!(" fire-staking initialized at: {:?}", staking_outpoint);
Ok(())
}

Verified Source