Source – Alkane 2:79125 — SUBFROST Explorer

src/tests/fire_foundation_proxied.rs21,810 B

//! # FIRE Proxied Foundation
//!
//! Production-shape deployment for integration tests:
//! 1. Deploy `fire-master-auth` → mints 1 unit master auth NFT
//! 2. Deploy 6 impl WASMs (no init, opcode 99 marker)
//! 3. Deploy NFT + staking templates (no init)
//! 4. Deploy 6 `fire-upgradeable` proxies, each bound to the shared auth
//! 5. Init each business contract through its proxy with master auth in incoming
//!
//! Returns a `ProxiedDeployment` that tests can build on top of (stake, bond,
//! redeem, claim, etc.) using the proxy addresses — exactly how mainnet works.
use crate::test_log;
use crate::tests::helpers::{
clear_test_environment, create_block_with_coinbase_tx,
create_multiple_cellpack_with_witness, create_multiple_cellpack_with_witness_and_in,
index_block,
};
use crate::tests::vendor::{
get_fire_bond_token_wasm_bytes, get_fire_bonding_wasm_bytes,
get_fire_position_token_wasm_bytes, get_fire_price_oracle_wasm_bytes,
get_fire_redemption_wasm_bytes, get_fire_series_token_wasm_bytes,
get_fire_staking_factory_wasm_bytes, get_fire_staking_wasm_bytes,
get_fire_token_wasm_bytes, get_fire_treasury_wasm_bytes,
};
use alkanes_support::cellpack::Cellpack;
use alkanes_support::envelope::RawEnvelope;
use alkanes_support::id::AlkaneId;
use anyhow::Result;
use bitcoin::{OutPoint, Witness};
// ── Slots (must match scripts/deploy-proxied.sh + boot.ts) ─────────────
pub const MASTER_AUTH_TX: u128 = 0xff; // 255
pub const FIRE_TOKEN_PROXY: u128 = 0x100; // 256
pub const FIRE_STAKING_FACTORY_PROXY: u128 = 0x101;
pub const FIRE_TREASURY_PROXY: u128 = 0x102;
pub const FIRE_BONDING_PROXY: u128 = 0x103;
pub const FIRE_REDEMPTION_PROXY: u128 = 0x104;
pub const FIRE_PRICE_ORACLE_PROXY: u128 = 0x105;
pub const FIRE_POSITION_TOKEN_TX: u128 = 0x106;
pub const FIRE_BOND_TOKEN_TX: u128 = 0x107;
pub const FIRE_SERIES_TOKEN_TX: u128 = 0x108;
pub const FIRE_TOKEN_IMPL: u128 = 0x200;
pub const FIRE_STAKING_FACTORY_IMPL: u128 = 0x201;
pub const FIRE_TREASURY_IMPL: u128 = 0x202;
pub const FIRE_BONDING_IMPL: u128 = 0x203;
pub const FIRE_REDEMPTION_IMPL: u128 = 0x204;
pub const FIRE_PRICE_ORACLE_IMPL: u128 = 0x205;
pub const FIRE_STAKING_TEMPLATE: u128 = 0x206; // staking-factory clones from this
pub fn master_auth_id() -> AlkaneId { AlkaneId { block: 4, tx: MASTER_AUTH_TX } }
pub fn fire_token_proxy() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_TOKEN_PROXY } }
pub fn fire_staking_factory() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_STAKING_FACTORY_PROXY } }
pub fn fire_treasury() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_TREASURY_PROXY } }
pub fn fire_bonding() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_BONDING_PROXY } }
pub fn fire_redemption() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_REDEMPTION_PROXY } }
pub fn fire_price_oracle() -> AlkaneId { AlkaneId { block: 4, tx: FIRE_PRICE_ORACLE_PROXY } }
fn master_auth_wasm() -> &'static [u8] { include_bytes!("./wasm/fire_master_auth.wasm") }
fn upgradeable_wasm() -> &'static [u8] { include_bytes!("./wasm/fire_upgradeable.wasm") }
/// Result of a full proxied FIRE deployment.
#[derive(Debug, Clone)]
pub struct ProxiedDeployment {
/// Current outpoint that carries the 1-unit master auth NFT.
/// Pass this as `auth_input` to subsequent admin/init operations.
pub master_auth_outpoint: OutPoint,
pub master_auth_id: AlkaneId,
pub fire_token_id: AlkaneId,
pub fire_staking_factory_id: AlkaneId,
pub fire_treasury_id: AlkaneId,
pub fire_bonding_id: AlkaneId,
pub fire_redemption_id: AlkaneId,
pub fire_price_oracle_id: AlkaneId,
pub fire_position_token_template: AlkaneId,
pub fire_bond_token_template: AlkaneId,
pub fire_series_token_template: AlkaneId,
pub fire_staking_template: AlkaneId,
pub start_height: u32,
pub current_height: u32,
}
/// Helper: deploy a WASM at slot `tx` in block 4 with the given init cellpack
/// (optionally consuming `auth_input` so auth NFT travels through).
/// Returns the new outpoint (vout 0) which carries any forwarded alkanes.
fn deploy_with_init(
height: u32,
wasm: &[u8],
slot: u128,
init_args: Vec<u128>,
auth_input: Option<OutPoint>,
) -> Result<OutPoint> {
let mut block = create_block_with_coinbase_tx(height);
let witness = RawEnvelope::from(wasm.to_vec()).to_witness(true);
let cellpack = Cellpack {
target: AlkaneId { block: 3, tx: slot },
inputs: init_args,
};
let tx = match auth_input {
Some(prev) => create_multiple_cellpack_with_witness_and_in(witness, vec![cellpack], prev, false),
None => create_multiple_cellpack_with_witness(witness, vec![cellpack], false),
};
let txid = tx.compute_txid();
block.txdata.push(tx);
index_block(&block, height)?;
Ok(OutPoint { txid, vout: 0 })
}
/// Helper: send a cellpack to an existing alkane, consuming `auth_input` (NFT
/// travels through unchanged). Returns the new outpoint.
fn call_through_proxy(
height: u32,
target: AlkaneId,
inputs: Vec<u128>,
auth_input: OutPoint,
) -> Result<OutPoint> {
let mut block = create_block_with_coinbase_tx(height);
let cellpack = Cellpack { target, inputs };
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![cellpack],
auth_input,
false,
);
let txid = tx.compute_txid();
block.txdata.push(tx);
index_block(&block, height)?;
Ok(OutPoint { txid, vout: 0 })
}
/// Mine an empty block (advances height for staking-emission accumulation).
pub fn mine_empty(height: u32) -> Result<()> {
let block = create_block_with_coinbase_tx(height);
index_block(&block, height)?;
Ok(())
}
/// Diagnostic: assert the master auth NFT is at the given outpoint with value 1.
fn debug_assert_auth(outpoint: &OutPoint, label: &str) -> Result<()> {
use crate::tests::helpers::get_sheet_by_outpoint;
let sheet = get_sheet_by_outpoint(outpoint)?;
let balance = sheet.get_cached(&master_auth_id().into());
test_log!("[AUTH-CHECK {}] outpoint={:?} balance={}", label, outpoint, balance);
if balance != 1 {
test_log!("[AUTH-CHECK FAIL] master auth NFT missing at {} (got {} expected 1)", label, balance);
}
Ok(())
}
/// Deploy fire-master-auth at a custom slot with `units` minted — used to spawn
/// fungible mock tokens (LP, etc.) in tests. Returns outpoint with `units` units.
pub fn deploy_mock_token(height: u32, slot: u128, units: u128) -> Result<OutPoint> {
deploy_with_init(height, master_auth_wasm(), slot, vec![0, units], None)
}
/// Query an epoch contract's AlkaneId via the factory's `GetEpochContract` view.
pub fn query_epoch_contract(factory: AlkaneId, epoch_index: u128, height: u32) -> Result<AlkaneId> {
let (resp, _) = simulate_cellpack(
height as u64,
Cellpack { target: factory, inputs: vec![11, epoch_index] },
)?;
if resp.data.len() < 32 {
return Err(anyhow::anyhow!("GetEpochContract returned {} bytes (need 32)", resp.data.len()));
}
let mut b = [0u8; 16];
let mut t = [0u8; 16];
b.copy_from_slice(&resp.data[0..16]);
t.copy_from_slice(&resp.data[16..32]);
Ok(AlkaneId {
block: u128::from_le_bytes(b),
tx: u128::from_le_bytes(t),
})
}
/// Full proxied deployment. Mirrors `scripts/deploy-proxied.sh` and
/// `subfrost-app/lib/devnet/boot.ts`.
///
/// `lp_token` — DIESEL/frBTC LP AlkaneId. Tests using a mock LP should pass a
/// deterministic id like `AlkaneId { block: 4, tx: 0xa00 }`.
/// `activation_block` — passed to staking-factory init (0 = production constant).
pub fn deploy_fire_proxied(
start_height: u32,
lp_token: AlkaneId,
activation_block: u128,
) -> Result<ProxiedDeployment> {
test_log!("\n[PROXIED] Starting full FIRE deployment at height {}", start_height);
let mut h = start_height;
// ── Phase 1: master auth ─────────────────────────────────────
test_log!("[PROXIED] Phase 1: fire-master-auth → 4:{:x}", MASTER_AUTH_TX);
let master_auth_out = deploy_with_init(
h,
master_auth_wasm(),
MASTER_AUTH_TX,
vec![0, 1], // Initialize(units=1)
None,
)?;
h += 1;
// ── Phase 2: business impl WASMs (no init — opcode 99 marker) ─
// CAUTION: some FIRE contracts' opcode 99 returns CallResponse::default()
// and does NOT forward incoming_alkanes — that would burn the auth NFT if
// threaded through. Keep the master auth at its mint outpoint and don't
// pass it as input to deploy/template txs.
debug_assert_auth(&master_auth_out, "after master_auth deploy")?;
test_log!("[PROXIED] Phase 2: impl WASMs (auth held at mint outpoint)");
let impls: Vec<(u128, &[u8])> = vec![
(FIRE_TOKEN_IMPL, get_fire_token_wasm_bytes()),
(FIRE_STAKING_FACTORY_IMPL, get_fire_staking_factory_wasm_bytes()),
(FIRE_TREASURY_IMPL, get_fire_treasury_wasm_bytes()),
(FIRE_BONDING_IMPL, get_fire_bonding_wasm_bytes()),
(FIRE_REDEMPTION_IMPL, get_fire_redemption_wasm_bytes()),
(FIRE_PRICE_ORACLE_IMPL, get_fire_price_oracle_wasm_bytes()),
];
for (slot, wasm) in impls {
deploy_with_init(h, wasm, slot, vec![99], None)?;
h += 1;
}
// ── Phase 3: NFT + staking templates ─────────────────────────
test_log!("[PROXIED] Phase 3: NFT + staking templates");
let templates: Vec<(u128, &[u8])> = vec![
(FIRE_POSITION_TOKEN_TX, get_fire_position_token_wasm_bytes()),
(FIRE_BOND_TOKEN_TX, get_fire_bond_token_wasm_bytes()),
(FIRE_SERIES_TOKEN_TX, get_fire_series_token_wasm_bytes()),
(FIRE_STAKING_TEMPLATE, get_fire_staking_wasm_bytes()),
];
for (slot, wasm) in templates {
deploy_with_init(h, wasm, slot, vec![99], None)?;
h += 1;
}
// ── Phase 4: 6 fire-upgradeable proxies ──────────────────────
// Proxy init doesn't touch incoming_alkanes (forwards them back per our
// fire-upgradeable code), but we play it safe and don't thread auth here.
test_log!("[PROXIED] Phase 4: 6 fire-upgradeable proxies");
let proxies: Vec<(u128, u128, &str)> = vec![
(FIRE_TOKEN_PROXY, FIRE_TOKEN_IMPL, "Token"),
(FIRE_STAKING_FACTORY_PROXY, FIRE_STAKING_FACTORY_IMPL, "StakingFactory"),
(FIRE_TREASURY_PROXY, FIRE_TREASURY_IMPL, "Treasury"),
(FIRE_BONDING_PROXY, FIRE_BONDING_IMPL, "Bonding"),
(FIRE_REDEMPTION_PROXY, FIRE_REDEMPTION_IMPL, "Redemption"),
(FIRE_PRICE_ORACLE_PROXY, FIRE_PRICE_ORACLE_IMPL, "PriceOracle"),
];
for (proxy_slot, impl_slot, label) in proxies {
test_log!("[PROXIED] {}: 4:{:x} → impl 4:{:x}", label, proxy_slot, impl_slot);
deploy_with_init(
h,
upgradeable_wasm(),
proxy_slot,
vec![0x7fff, 4, impl_slot, 4, MASTER_AUTH_TX],
None,
)?;
h += 1;
}
// Auth NFT is still at master_auth_out — start threading it in phase 5.
debug_assert_auth(&master_auth_out, "before business init phase")?;
let mut auth = master_auth_out;
// ── Phase 5: business init through proxies (master auth in incoming) ─
test_log!("[PROXIED] Phase 5: init business contracts");
// fire-token: Init(staking_authority=factory_proxy, bonding_contract=bonding_proxy)
auth = call_through_proxy(
h, fire_token_proxy(),
vec![0, 4, FIRE_STAKING_FACTORY_PROXY, 4, FIRE_BONDING_PROXY],
auth,
)?;
debug_assert_auth(&auth, "after fire-token init")?;
h += 1;
// fire-treasury: Init(fire_token, diesel_lp, bonding, redemption)
auth = call_through_proxy(
h, fire_treasury(),
vec![0,
4, FIRE_TOKEN_PROXY,
lp_token.block, lp_token.tx,
4, FIRE_BONDING_PROXY,
4, FIRE_REDEMPTION_PROXY],
auth,
)?;
h += 1;
// fire-redemption: Init(fire_token, treasury)
auth = call_through_proxy(
h, fire_redemption(),
vec![0, 4, FIRE_TOKEN_PROXY, 4, FIRE_TREASURY_PROXY],
auth,
)?;
h += 1;
// fire-bonding: Init(fire, lp, treasury, oracle, bond_tmpl, genesis_height)
auth = call_through_proxy(
h, fire_bonding(),
vec![0,
4, FIRE_TOKEN_PROXY,
lp_token.block, lp_token.tx,
4, FIRE_TREASURY_PROXY,
4, FIRE_PRICE_ORACLE_PROXY,
FIRE_BOND_TOKEN_TX,
0], // genesis_height=0 → uses ACTIVATION_BLOCK constant
auth,
)?;
h += 1;
// fire-staking-factory: Init(lp, fire, staking_tpl, pos_tpl, wlp_tpl, activation, beacon)
// Both beacon AlkaneIds = {0,0}: direct template clones (no beacon layer for the
// WASM harness — production sets beacons but tests don't need upgrade flow).
auth = call_through_proxy(
h, fire_staking_factory(),
vec![0,
lp_token.block, lp_token.tx,
4, FIRE_TOKEN_PROXY,
FIRE_STAKING_TEMPLATE,
FIRE_POSITION_TOKEN_TX,
FIRE_SERIES_TOKEN_TX,
activation_block,
0, 0, // staking beacon
0, 0], // position beacon
auth,
)?;
h += 1;
// fire-price-oracle: Init(factory) — opcode 2, NOT 0
auth = call_through_proxy(
h, fire_price_oracle(),
vec![2, 4, FIRE_STAKING_FACTORY_PROXY],
auth,
)?;
h += 1;
test_log!("[PROXIED] ✓ Full deployment complete at height {}", h);
Ok(ProxiedDeployment {
master_auth_outpoint: auth,
master_auth_id: master_auth_id(),
fire_token_id: fire_token_proxy(),
fire_staking_factory_id: fire_staking_factory(),
fire_treasury_id: fire_treasury(),
fire_bonding_id: fire_bonding(),
fire_redemption_id: fire_redemption(),
fire_price_oracle_id: fire_price_oracle(),
fire_position_token_template: AlkaneId { block: 4, tx: FIRE_POSITION_TOKEN_TX },
fire_bond_token_template: AlkaneId { block: 4, tx: FIRE_BOND_TOKEN_TX },
fire_series_token_template: AlkaneId { block: 4, tx: FIRE_SERIES_TOKEN_TX },
fire_staking_template: AlkaneId { block: 4, tx: FIRE_STAKING_TEMPLATE },
start_height,
current_height: h,
})
}
// ── Smoke test for the harness itself ────────────────────────────────
use wasm_bindgen_test::wasm_bindgen_test;
use crate::tests::helpers::{get_sheet_by_outpoint, simulate_cellpack};
#[wasm_bindgen_test]
fn delegate_test_nft_survives_proxy_view_call() -> anyhow::Result<()> {
// Verify: sending an NFT in incoming to a view-only opcode that goes through
// proxy → delegatecall → impl → returns CallResponse::forward(incoming),
// the NFT must come back.
clear_test_environment();
test_log!("\n=== delegate_test_nft_survives_proxy_view_call ===");
let mut h = 880_000u32;
let master_auth_out = deploy_with_init(h, master_auth_wasm(), MASTER_AUTH_TX, vec![0, 1], None)?;
h += 1;
deploy_with_init(h, get_fire_token_wasm_bytes(), FIRE_TOKEN_IMPL, vec![99], None)?;
h += 1;
deploy_with_init(
h, upgradeable_wasm(), FIRE_TOKEN_PROXY,
vec![0x7fff, 4, FIRE_TOKEN_IMPL, 4, MASTER_AUTH_TX], None,
)?;
h += 1;
debug_assert_auth(&master_auth_out, "before proxy view call")?;
// Call GetName (opcode 99) through proxy with master auth NFT in incoming.
// fire-token::get_name does CallResponse::forward(incoming_alkanes) so the
// NFT must come back.
let post = call_through_proxy(h, fire_token_proxy(), vec![99], master_auth_out)?;
debug_assert_auth(&post, "after proxy GetName view")?;
Ok(())
}
#[wasm_bindgen_test]
fn delegate_test_business_init_through_proxy_with_auth() -> anyhow::Result<()> {
// Minimal repro of the business init flow that's failing:
// master auth → fire-token impl → fire-upgradeable proxy →
// call proxy with opcode 0 + master auth NFT in incoming → impl.only_owner() must pass.
clear_test_environment();
test_log!("\n=== delegate_test_business_init_through_proxy_with_auth ===");
let mut h = 880_000u32;
// 1. Master auth
let master_auth_out = deploy_with_init(h, master_auth_wasm(), MASTER_AUTH_TX, vec![0, 1], None)?;
h += 1;
debug_assert_auth(&master_auth_out, "after master_auth deploy")?;
// 2. fire-token impl (no init)
deploy_with_init(h, get_fire_token_wasm_bytes(), FIRE_TOKEN_IMPL, vec![99], None)?;
h += 1;
// 3. fire-upgradeable proxy bound to master auth
deploy_with_init(
h,
upgradeable_wasm(),
FIRE_TOKEN_PROXY,
vec![0x7fff, 4, FIRE_TOKEN_IMPL, 4, MASTER_AUTH_TX],
None,
)?;
h += 1;
// 4. Mock staking factory + bonding contract addresses (real init needs them)
// For this isolated test we just point them at fictional slots — fire-token doesn't validate them.
// 5. Call init through proxy with master auth NFT in incoming.
// fire-token::Initialize(staking_contract, bonding_contract) takes 2 AlkaneIds.
// Use Tracer to see what actually happens inside the call chain.
use crate::tests::helpers::Tracer;
let mut block = create_block_with_coinbase_tx(h);
let cellpack = Cellpack {
target: fire_token_proxy(),
inputs: vec![0, 4, FIRE_STAKING_FACTORY_PROXY, 4, FIRE_BONDING_PROXY],
};
let tx = create_multiple_cellpack_with_witness_and_in(
Witness::new(), vec![cellpack], master_auth_out, false,
);
let txid = tx.compute_txid();
block.txdata.push(tx);
let tracer = Tracer::new("init-fire-token-via-proxy");
tracer.index_and_trace(&block, h)?;
let post = OutPoint { txid, vout: 0 };
debug_assert_auth(&post, "after fire-token init through proxy")?;
Ok(())
}
#[wasm_bindgen_test]
fn delegate_test_proxy_forwards_view_to_impl() -> anyhow::Result<()> {
// Minimal repro: deploy fire-token impl + fire-upgradeable proxy,
// simulate opcode 99 (GetName) — proxy should delegate to impl.
clear_test_environment();
test_log!("\n=== delegate_test_proxy_forwards_view_to_impl ===");
let mut h = 880_000u32;
// Master auth
deploy_with_init(h, master_auth_wasm(), MASTER_AUTH_TX, vec![0, 1], None)?;
h += 1;
// fire-token impl
deploy_with_init(h, get_fire_token_wasm_bytes(), FIRE_TOKEN_IMPL, vec![99], None)?;
h += 1;
// fire-upgradeable proxy → impl, shared auth
deploy_with_init(
h,
upgradeable_wasm(),
FIRE_TOKEN_PROXY,
vec![0x7fff, 4, FIRE_TOKEN_IMPL, 4, MASTER_AUTH_TX],
None,
)?;
h += 1;
// Simulate GetMaxSupply (opcode 102) — returns hardcoded constant, no init needed.
match simulate_cellpack(h as u64, Cellpack { target: fire_token_proxy(), inputs: vec![102] }) {
Ok((resp, _)) => {
test_log!("[DELEGATE] proxy GetMaxSupply → {} bytes: {:02x?}", resp.data.len(), &resp.data);
assert!(!resp.data.is_empty(), "proxy must delegate GetMaxSupply to impl (constant)");
// Parse first 16 bytes as u128 LE
let mut bytes = [0u8; 16];
bytes.copy_from_slice(&resp.data[..16]);
let supply = u128::from_le_bytes(bytes);
test_log!("[DELEGATE] decoded max supply: {}", supply);
assert_eq!(supply, 210_000_000_000_000, "MAX_SUPPLY = 2.1M * 1e8");
}
Err(e) => {
test_log!("[DELEGATE] proxy GetMaxSupply ERR: {:?}", e);
panic!("proxy delegation failed: {:?}", e);
}
}
Ok(())
}
#[wasm_bindgen_test]
fn proxied_deployment_smoke() -> anyhow::Result<()> {
clear_test_environment();
test_log!("\n=== proxied_deployment_smoke ===");
let lp_token = AlkaneId { block: 4, tx: 0xa00 }; // mock LP
let dep = deploy_fire_proxied(880_000, lp_token, 880_100)?;
// Master auth NFT survived all 19 transactions (1 mint + 6 impl + 4 tmpl + 6 proxy + 6 init... wait actually 1+6+4+6+6 = 23 txs, hmm let me recount).
let sheet = get_sheet_by_outpoint(&dep.master_auth_outpoint)?;
let auth_balance = sheet.get_cached(&dep.master_auth_id.into());
test_log!("[SMOKE] master auth NFT survives full deploy: {}", auth_balance);
assert_eq!(auth_balance, 1, "master auth NFT must survive entire proxied deploy");
// Each proxy responds to a simple view via simulate.
for (name, target, opcode) in [
("fire-token GetName", dep.fire_token_id, 99u128),
("fire-treasury GetName", dep.fire_treasury_id, 99),
("fire-bonding GetName", dep.fire_bonding_id, 99),
("fire-redemption GetName", dep.fire_redemption_id, 20),
("fire-price-oracle GetName", dep.fire_price_oracle_id, 99),
("fire-staking-factory GetName", dep.fire_staking_factory_id, 99),
] {
match simulate_cellpack(dep.current_height as u64, Cellpack { target, inputs: vec![opcode] }) {
Ok((resp, _)) => {
test_log!("[SMOKE] {} → ok, {} bytes", name, resp.data.len());
}
Err(e) => {
test_log!("[SMOKE] {} → ERR {:?}", name, e);
// Not all opcodes are pure views — this is informational.
}
}
}
Ok(())
}

Verified Source