Source – Alkane 2:86901 — SUBFROST Explorer

src/tests/foundation.rs12,596 B

//! # Foundation E2E Tests
//!
//! This module tests the foundational infrastructure needed for FIRE staking:
//! 1. Minting DIESEL [2:0] using opcode 77 (free mint once per block)
//! 2. Minting frBTC [32:0] using opcode 77 (Wrap - requires BTC)
//! 3. Deploying OYL AMM Factory
//! 4. Creating frBTC/DIESEL LP pool
//! 5. Adding liquidity to get LP tokens for FIRE staking tests
//!
//! This foundation is used by all FIRE tests to ensure a consistent base layer.
use crate::tests::helpers::{
clear_test_environment, init_with_multiple_cellpacks_with_tx, index_block,
create_multiple_cellpack_with_witness_and_txins_edicts, get_sheet_by_outpoint,
DIESEL_ID, FR_BTC_ID,
};
use crate::tests::amm_setup::{setup_amm, AmmDeployment};
use crate::test_log;
use alkanes_support::cellpack::Cellpack;
use alkanes_support::id::AlkaneId;
use anyhow::Result;
use bitcoin::{
Amount, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Witness, XOnlyPublicKey,
};
use bitcoin::key::{Secp256k1, TapTweak};
use protorune::test_helpers::create_block_with_coinbase_tx;
use protorune_support::balance_sheet::ProtoruneRuneId;
use protorune_support::protostone::ProtostoneEdict;
use wasm_bindgen_test::wasm_bindgen_test;
// DEFAULT_SIGNER_PUBKEY from fr-btc-support (for wrapping BTC to frBTC)
pub const DEFAULT_SIGNER_PUBKEY: [u8; 32] = [
0x79, 0x40, 0xef, 0x3b, 0x65, 0x91, 0x79, 0xa1, 0x37, 0x1d, 0xec, 0x05, 0x79, 0x3c, 0xb0, 0x27,
0xcd, 0xe4, 0x78, 0x06, 0xfb, 0x66, 0xce, 0x1e, 0x3d, 0x1b, 0x69, 0xd5, 0x6d, 0xe6, 0x29, 0xdc,
];
/// Helper to create frBTC signer output script
pub fn create_frbtc_signer_script() -> ScriptBuf {
let signer_pubkey = XOnlyPublicKey::from_slice(&DEFAULT_SIGNER_PUBKEY).unwrap();
let secp = Secp256k1::new();
let (tweaked_signer_pubkey, _) = signer_pubkey.tap_tweak(&secp, None);
ScriptBuf::new_p2tr_tweaked(tweaked_signer_pubkey)
}
/// Mint DIESEL tokens using opcode 77 (free mint, once per block)
/// Returns (diesel_amount, diesel_outpoint)
pub fn mint_diesel(block_height: u32) -> Result<(u128, OutPoint)> {
test_log!("[FOUNDATION] Minting DIESEL via opcode 77 (free mint)");
let cellpack = Cellpack {
target: DIESEL_ID,
inputs: vec![77], // Mint opcode for DIESEL
};
let mint_block = init_with_multiple_cellpacks_with_tx(vec![vec![]], vec![cellpack]);
index_block(&mint_block, block_height)?;
let diesel_outpoint = OutPoint {
txid: mint_block.txdata[1].compute_txid(),
vout: 0, // Output 0 contains the tokens
};
// Get the actual DIESEL balance from the outpoint
let diesel_sheet = get_sheet_by_outpoint(&diesel_outpoint)?;
let diesel_amount = diesel_sheet.get_cached(&DIESEL_ID.into());
test_log!("[FOUNDATION] Minted {} DIESEL at {:?}", diesel_amount, diesel_outpoint);
Ok((diesel_amount, diesel_outpoint))
}
/// Mint frBTC by wrapping BTC (opcode 77)
/// The transaction must have an OUTPUT paying BTC to the signer address.
/// The amount of BTC in that output determines how much frBTC gets minted.
/// Returns (frbtc_amount, frbtc_outpoint)
pub fn mint_frbtc(block_height: u32, btc_amount_sats: u64) -> Result<(u128, OutPoint)> {
test_log!("[FOUNDATION] Minting frBTC via Wrap (opcode 77) - {} sats", btc_amount_sats);
let signer_script = create_frbtc_signer_script();
// Create cellpack for wrap operation
let cellpack = Cellpack {
target: FR_BTC_ID,
inputs: vec![77], // Wrap opcode
};
// Create the wrap transaction with OUTPUT paying to signer
let wrap_tx = create_multiple_cellpack_with_witness_and_txins_edicts(
vec![cellpack],
vec![TxIn {
previous_output: OutPoint::null(),
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness: Witness::default(),
}],
false,
vec![],
);
// Modify output 0 to pay to the signer address (this determines frBTC mint amount)
let mut modified_tx = wrap_tx;
modified_tx.output[0] = TxOut {
value: Amount::from_sat(btc_amount_sats),
script_pubkey: signer_script,
};
let mut wrap_block = create_block_with_coinbase_tx(block_height);
wrap_block.txdata.push(modified_tx);
index_block(&wrap_block, block_height)?;
let wrap_outpoint = OutPoint {
txid: wrap_block.txdata[1].compute_txid(),
vout: 0,
};
// The amount minted equals the BTC amount paid to signer
let fr_btc_balance = btc_amount_sats as u128;
test_log!("[FOUNDATION] Minted {} frBTC at {:?}", fr_btc_balance, wrap_outpoint);
Ok((fr_btc_balance, wrap_outpoint))
}
/// Create a pool creation transaction that spends token outpoints
pub fn create_pool_creation_tx(
factory_proxy_id: AlkaneId,
token_a: AlkaneId,
token_b: AlkaneId,
amount_a: u128,
amount_b: u128,
outpoint_a: OutPoint,
outpoint_b: OutPoint,
) -> Transaction {
// Create edicts to send tokens to output 0 (where the contract executes)
let edicts = vec![
ProtostoneEdict {
id: ProtoruneRuneId { block: token_a.block, tx: token_a.tx },
amount: amount_a,
output: 0,
},
ProtostoneEdict {
id: ProtoruneRuneId { block: token_b.block, tx: token_b.tx },
amount: amount_b,
output: 0,
},
];
// CreatePool opcode with token addresses
let cellpack = Cellpack {
target: factory_proxy_id,
inputs: vec![
1, // CreatePool opcode
token_a.block,
token_a.tx,
token_b.block,
token_b.tx,
],
};
// Build transaction spending both token outpoints
let txins = vec![
TxIn {
previous_output: outpoint_a,
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness: Witness::new(),
},
TxIn {
previous_output: outpoint_b,
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness: Witness::new(),
},
];
create_multiple_cellpack_with_witness_and_txins_edicts(
vec![cellpack],
txins,
false,
edicts,
)
}
/// Create frBTC/DIESEL LP pool and add initial liquidity
/// Returns (lp_token_id, lp_amount, lp_outpoint)
pub fn create_lp_pool_with_liquidity(
block_height: u32,
amm_deployment: &AmmDeployment,
frbtc_amount: u128,
diesel_amount: u128,
diesel_outpoint: OutPoint,
frbtc_outpoint: OutPoint,
) -> Result<(AlkaneId, u128, OutPoint)> {
use alkanes::vm::utils::sequence_pointer;
use metashrew_core::index_pointer::AtomicPointer;
use metashrew_support::index_pointer::KeyValuePointer;
test_log!("[FOUNDATION] Creating frBTC/DIESEL LP pool");
test_log!("[FOUNDATION] frBTC: {}, DIESEL: {}", frbtc_amount, diesel_amount);
// Get next sequence number for the LP token
let next_sequence_pointer = sequence_pointer(&mut AtomicPointer::default());
let pool_sequence = next_sequence_pointer.get_value::<u128>();
// Create pool transaction
let create_pool_tx = create_pool_creation_tx(
amm_deployment.factory_proxy_id,
FR_BTC_ID,
DIESEL_ID,
frbtc_amount,
diesel_amount,
frbtc_outpoint,
diesel_outpoint,
);
let mut create_pool_block = create_block_with_coinbase_tx(block_height);
create_pool_block.txdata.push(create_pool_tx);
index_block(&create_pool_block, block_height)?;
// LP token is created at [2, pool_sequence]
let lp_token_id = AlkaneId { block: 2, tx: pool_sequence };
let lp_outpoint = OutPoint {
txid: create_pool_block.txdata[1].compute_txid(),
vout: 0,
};
// LP tokens = sqrt(frbtc * diesel) - 1000 (MINIMUM_LIQUIDITY)
let lp_amount = ((frbtc_amount as f64 * diesel_amount as f64).sqrt() as u128).saturating_sub(1000);
test_log!("[FOUNDATION] LP pool created: {:?}", lp_token_id);
test_log!("[FOUNDATION] LP tokens minted: {}", lp_amount);
Ok((lp_token_id, lp_amount, lp_outpoint))
}
/// Complete foundation state for FIRE tests
#[derive(Debug, Clone)]
pub struct FoundationState {
pub diesel_amount: u128,
pub diesel_outpoint: OutPoint,
pub frbtc_amount: u128,
pub frbtc_outpoint: OutPoint,
pub amm_deployment: AmmDeployment,
pub lp_token_id: AlkaneId,
pub lp_amount: u128,
pub lp_outpoint: OutPoint,
pub current_height: u32,
}
/// Setup complete foundation: DIESEL, frBTC, AMM, and LP pool
pub fn setup_foundation(start_height: u32) -> Result<FoundationState> {
test_log!("\n[FOUNDATION] ===== Starting Foundation Setup =====");
clear_test_environment();
let mut height = start_height;
// 1. Mint DIESEL tokens
let (diesel_amount, diesel_outpoint) = mint_diesel(height)?;
height += 1;
// 2. Mint frBTC (1 BTC = 100_000_000 sats)
let (frbtc_amount, frbtc_outpoint) = mint_frbtc(height, 100_000_000)?;
height += 1;
// 3. Deploy AMM Factory
let amm_deployment = setup_amm(height)?;
height = amm_deployment.current_height + 1;
// 4. Create LP pool with 50% of each token
let liq_frbtc = frbtc_amount / 2;
let liq_diesel = diesel_amount / 2;
let (lp_token_id, lp_amount, lp_outpoint) = create_lp_pool_with_liquidity(
height,
&amm_deployment,
liq_frbtc,
liq_diesel,
diesel_outpoint,
frbtc_outpoint,
)?;
height += 1;
test_log!("[FOUNDATION] ===== Foundation Setup Complete =====\n");
Ok(FoundationState {
diesel_amount: diesel_amount - liq_diesel,
diesel_outpoint,
frbtc_amount: frbtc_amount - liq_frbtc,
frbtc_outpoint,
amm_deployment,
lp_token_id,
lp_amount,
lp_outpoint,
current_height: height,
})
}
// ============ Tests ============
#[wasm_bindgen_test]
fn test_diesel_minting() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: DIESEL Minting");
test_log!("======================================================================\n");
let (diesel_amount, diesel_outpoint) = mint_diesel(880_000)?;
assert!(diesel_amount > 0, "DIESEL not minted");
test_log!("DIESEL minted: {} at {:?}", diesel_amount, diesel_outpoint);
Ok(())
}
#[wasm_bindgen_test]
fn test_frbtc_minting() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: frBTC Minting (Wrap)");
test_log!("======================================================================\n");
let btc_amount = 100_000_000u64; // 1 BTC
let (frbtc_amount, frbtc_outpoint) = mint_frbtc(880_000, btc_amount)?;
assert_eq!(frbtc_amount, btc_amount as u128, "frBTC amount should equal BTC wrapped");
test_log!("frBTC minted: {} at {:?}", frbtc_amount, frbtc_outpoint);
Ok(())
}
#[wasm_bindgen_test]
fn test_amm_deployment() -> Result<()> {
clear_test_environment();
test_log!("\n======================================================================");
test_log!("TEST: AMM Factory Deployment");
test_log!("======================================================================\n");
let amm = setup_amm(880_000)?;
test_log!("Factory proxy: {:?}", amm.factory_proxy_id);
test_log!("Pool template: {:?}", amm.pool_template_id);
test_log!("Pool beacon: {:?}", amm.pool_upgradeable_beacon_id);
assert!(amm.factory_proxy_id.tx > 0, "Factory proxy not deployed");
Ok(())
}
#[wasm_bindgen_test]
fn test_foundation_setup() -> Result<()> {
test_log!("\n======================================================================");
test_log!("TEST: Complete Foundation Setup");
test_log!("======================================================================\n");
let foundation = setup_foundation(880_000)?;
// Verify all components
assert!(foundation.diesel_amount > 0, "DIESEL not minted");
assert!(foundation.frbtc_amount > 0, "frBTC not minted");
assert!(foundation.lp_amount > 0, "LP tokens not minted");
test_log!("Foundation setup complete:");
test_log!(" DIESEL remaining: {}", foundation.diesel_amount);
test_log!(" frBTC remaining: {}", foundation.frbtc_amount);
test_log!(" LP token: {:?}", foundation.lp_token_id);
test_log!(" LP amount: {}", foundation.lp_amount);
Ok(())
}

Verified Source