Source – Alkane 2:87488 — SUBFROST Explorer

alkanes/fire-treasury/src/lib.rs9,180 B

//! FIRE Treasury Contract — Minimal & Immutable
//!
//! Passive treasury that holds LP tokens as backing for FIRE redemption floor.
//! No admin ops. All parameters immutable after init.
//! Treasury fills organically via bonding LP deposits.
//!
//! floor_price = treasury_LP / total_fire_supply
use alkanes_runtime::{
auth::AuthenticatedResponder,
declare_alkane, message::MessageDispatch, runtime::AlkaneResponder, storage::StoragePointer,
};
#[allow(unused_imports)]
use alkanes_runtime::{
println,
stdio::{stdout, Write},
};
use alkanes_support::{
cellpack::Cellpack,
id::AlkaneId,
parcel::{AlkaneTransfer, AlkaneTransferParcel},
response::CallResponse,
};
use anyhow::{anyhow, Result};
use fire_support::DECIMAL_FACTOR;
use ruint::aliases::U256;
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
#[derive(Default)]
pub struct FireTreasury(());
impl AlkaneResponder for FireTreasury {}
impl AuthenticatedResponder for FireTreasury {}
#[derive(MessageDispatch)]
enum FireTreasuryMessage {
/// Initialize treasury with all references (immutable after init)
#[opcode(0)]
Initialize {
fire_token: AlkaneId,
diesel_lp_token: AlkaneId,
bonding_contract: AlkaneId,
redemption_contract: AlkaneId,
},
/// Accept incoming LP/tokens (from bonding, etc.)
#[opcode(10)]
Deposit,
/// Release proportional LP backing (only redemption contract)
#[opcode(11)]
RedeemBacking { fire_amount: u128 },
/// Get current redemption rate (LP per FIRE)
#[opcode(23)]
#[returns(u128)]
GetRedemptionRate,
/// Get total LP backing held by treasury
#[opcode(24)]
#[returns(u128)]
GetTotalBacking,
/// Safe deploy opcode for CREATERESERVED
#[opcode(99)]
#[returns(String)]
GetName,
}
impl FireTreasury {
// ── Storage ────────────────────────────────────────────────────
fn fire_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/fire_token")
}
fn diesel_lp_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/diesel_lp_token")
}
fn bonding_contract_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/bonding_contract")
}
fn redemption_contract_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/redemption_contract")
}
// ── Getters ───────────────────────────────────────────────────
fn fire_token(&self) -> Result<AlkaneId> {
let data = self.fire_token_pointer().get();
if data.is_empty() { return Err(anyhow!("FIRE token not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn diesel_lp_token(&self) -> Result<AlkaneId> {
let data = self.diesel_lp_token_pointer().get();
if data.is_empty() { return Err(anyhow!("DIESEL LP token not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn bonding_contract(&self) -> Result<AlkaneId> {
let data = self.bonding_contract_pointer().get();
if data.is_empty() { return Err(anyhow!("bonding contract not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn redemption_contract(&self) -> Result<AlkaneId> {
let data = self.redemption_contract_pointer().get();
if data.is_empty() { return Err(anyhow!("redemption contract not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
// ── Helpers ───────────────────────────────────────────────────
fn query_total_fire_supply(&self) -> Result<u128> {
let fire_token = self.fire_token()?;
let cellpack = Cellpack {
target: fire_token,
inputs: vec![101], // GetTotalSupply
};
let response = self.staticcall(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
if response.data.len() >= 16 {
Ok(u128::from_le_bytes(response.data[0..16].try_into().map_err(|_| anyhow!("parse error"))?))
} else {
Err(anyhow!("fire-token returned no supply data"))
}
}
fn only_authorized(&self, contract_type: u128) -> Result<()> {
let context = self.context()?;
let authorized = match contract_type {
0 => self.bonding_contract()?,
1 => self.redemption_contract()?,
_ => return Err(anyhow!("invalid contract type")),
};
if context.caller != authorized {
return Err(anyhow!("unauthorized caller"));
}
Ok(())
}
// ── Handlers ──────────────────────────────────────────────────
fn initialize(
&self,
fire_token: AlkaneId,
diesel_lp_token: AlkaneId,
bonding_contract: AlkaneId,
redemption_contract: AlkaneId,
) -> Result<CallResponse> {
// If behind proxy (/auth set), require auth token to prevent init race.
// Direct deploy (/auth empty) has no race — init is atomic with CREATERESERVED.
if self.auth_token_pointer().get().len() > 0 {
self.only_owner()?;
}
self.observe_initialization()?;
self.fire_token_pointer().set(Arc::new(fire_token.into()));
self.diesel_lp_token_pointer().set(Arc::new(diesel_lp_token.into()));
self.bonding_contract_pointer().set(Arc::new(bonding_contract.into()));
self.redemption_contract_pointer().set(Arc::new(redemption_contract.into()));
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn deposit(&self) -> Result<CallResponse> {
// Keep only LP token; return anything else to caller.
// deposit() has no auth — anyone can call it, so non-LP tokens
// must not get stuck on treasury.
let context = self.context()?;
let diesel_lp = self.diesel_lp_token()?;
let mut response = CallResponse::default();
for transfer in &context.incoming_alkanes.0 {
if transfer.id != diesel_lp {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
fn redeem_backing(&self, fire_amount: u128) -> Result<CallResponse> {
self.only_authorized(1)?; // only redemption contract
let context = self.context()?;
let diesel_lp = self.diesel_lp_token()?;
let total_supply = self.query_total_fire_supply()?;
if total_supply == 0 {
return Err(anyhow!("no FIRE supply"));
}
let lp_balance = self.balance(&context.myself, &diesel_lp);
// U256 intermediate prevents overflow when lp_balance * fire_amount
// exceeds u128::MAX (realistic with large supply + backing).
let lp_share: u128 = (U256::from(lp_balance) * U256::from(fire_amount)
/ U256::from(total_supply))
.try_into()
.map_err(|_| anyhow!("lp_share overflow"))?;
let mut response = CallResponse::default();
if lp_share > 0 {
response.alkanes.0.push(AlkaneTransfer {
id: diesel_lp,
value: lp_share,
});
}
Ok(response)
}
fn get_redemption_rate(&self) -> Result<CallResponse> {
let context = self.context()?;
let diesel_lp = self.diesel_lp_token()?;
let lp_balance = self.balance(&context.myself, &diesel_lp);
let total_supply = self.query_total_fire_supply().unwrap_or(0);
let rate: u128 = if total_supply > 0 {
// U256 intermediate so lp_balance * DECIMAL_FACTOR can't overflow.
(U256::from(lp_balance) * U256::from(DECIMAL_FACTOR) / U256::from(total_supply))
.try_into()
.unwrap_or(u128::MAX)
} else {
0
};
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = rate.to_le_bytes().to_vec();
Ok(response)
}
fn get_total_backing(&self) -> Result<CallResponse> {
let context = self.context()?;
let diesel_lp = self.diesel_lp_token()?;
let lp_balance = self.balance(&context.myself, &diesel_lp);
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = lp_balance.to_le_bytes().to_vec();
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data = b"FIRE Treasury".to_vec();
Ok(r)
}
}
declare_alkane! {
impl AlkaneResponder for FireTreasury {
type Message = FireTreasuryMessage;
}
}

Verified Source