Source – Alkane 2:87050 — SUBFROST Explorer

alkanes/fire-bonding/src/lib.rs28,511 B

//! FIRE Bonding Contract — Bond Position Token Architecture
//!
//! Allows users to bond DIESEL/frBTC LP tokens to receive FIRE at a discount.
//! Bonded LP goes to treasury, building protocol-owned liquidity.
//! FIRE is vested over a period to prevent immediate arbitrage dumps.
//!
//! Rate-limited: bonding capacity unlocks linearly at bonding_emission_rate per block.
//! Halving happens automatically via check_epoch() — no factory needed for bonding.
//! Each epoch resets total_bonded_fire to 0.
//!
//! Each bond() creates a bond position token NFT returned to the user.
//! ClaimVested requires sending the position token as incomingAlkanes.
//! Ownership = holding the token. No context.caller dependency.
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, BONDING_EMISSION_RATE, HALVING_INTERVAL, ACTIVATION_BLOCK, WEEK, get_emission_rate_for_epoch};
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
/// Default bonding parameters
pub const DEFAULT_DISCOUNT_BPS: u128 = 1000; // 10% discount
/// Default bond vesting period. Mainnet: 1,050 blocks (~7 days). Devnet: 2 blocks
/// (HALVING_INTERVAL=200, WEEK=2). Tracks fire_support::WEEK so devnet builds
/// have fast vesting for end-to-end testing.
pub const DEFAULT_VESTING_PERIOD: u64 = WEEK;
pub const MAX_DISCOUNT_BPS: u128 = 2000; // 20% max discount
/// Bond position token opcodes
const BOND_POS_SET_CLAIMED: u128 = 1;
const BOND_POS_GET_ALL_DETAILS: u128 = 23;
/// Opcode for minting from FIRE token's bonding emission pool
const FIRE_MINT_BONDING_OPCODE: u128 = 78;
#[derive(Default)]
pub struct FireBonding(());
impl AlkaneResponder for FireBonding {}
impl AuthenticatedResponder for FireBonding {}
#[derive(MessageDispatch)]
enum FireBondingMessage {
/// Initialize bonding contract.
/// genesis_height: 0 = use ACTIVATION_BLOCK (950,420). >0 = override (devnet).
#[opcode(0)]
Initialize {
fire_token: AlkaneId,
diesel_lp_token: AlkaneId,
treasury: AlkaneId,
price_oracle: AlkaneId,
bond_position_template: u128,
genesis_height: u128,
},
/// Bond LP tokens for discounted FIRE. Returns bond position token.
/// lp_to_bond: amount of LP to bond (0 = all incoming LP)
/// min_fire_out: minimum FIRE expected (slippage protection, 0 = no check)
#[opcode(1)]
Bond { lp_to_bond: u128, min_fire_out: u128 },
/// Claim vested FIRE. Send bond position token as incomingAlkanes.
/// target_position: AlkaneId of bond NFT to claim ({0,0} = first found)
#[opcode(2)]
ClaimVested { target_position: AlkaneId },
/// Admin: Set discount rate (basis points)
#[opcode(4)]
SetDiscount { discount_bps: u128 },
/// Admin: Pause/unpause bonding
#[opcode(6)]
SetPaused { paused: u128 },
/// Admin: Update price oracle contract
#[opcode(7)]
SetPriceOracle { oracle: AlkaneId },
// ── View functions ──────────────────────────────────────────
#[opcode(20)]
#[returns(u128)]
GetCurrentDiscount,
#[opcode(21)]
#[returns(u128)]
GetFirePrice,
#[opcode(22)]
#[returns(u128)]
GetAvailableCapacity,
#[opcode(23)]
#[returns(u128)]
GetTotalBondedFire,
#[opcode(24)]
#[returns(u128)]
GetCurrentHalvingEpoch,
#[opcode(30)]
#[returns(u128)]
GetBondPositionTemplate,
#[opcode(31)]
#[returns(u128)]
GetBondCount,
#[opcode(32)]
#[returns(u128)]
GetEmissionRate,
#[opcode(33)]
#[returns(u128)]
GetTotalClaimedFire,
/// Safe deploy opcode for CREATERESERVED
#[opcode(99)]
#[returns(String)]
GetName,
}
impl FireBonding {
// ============ Storage Pointers ============
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 treasury_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/treasury")
}
fn price_oracle_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/price_oracle")
}
fn discount_bps_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/discount_bps")
}
fn vesting_period_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/vesting_period")
}
fn paused_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/paused")
}
fn total_bonded_fire_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_bonded_fire")
}
fn total_claimed_fire_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_claimed_fire")
}
fn total_bonded_lp_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_bonded_lp")
}
fn bond_position_template_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/bond_position_template")
}
fn bond_count_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/bond_count")
}
/// Genesis height — used to calculate halving epoch
fn genesis_height_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/genesis_height")
}
/// Current halving epoch (0, 1, 2...)
fn halving_epoch_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/halving_epoch")
}
/// Block where current epoch started (for capacity calculation)
fn epoch_start_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/epoch_start")
}
fn child_registered_pointer(&self, id: &AlkaneId) -> StoragePointer {
StoragePointer::from_keyword("/child_reg/")
.select(&<AlkaneId as Into<Vec<u8>>>::into(id.clone()))
}
// ============ 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 treasury(&self) -> Result<AlkaneId> {
let data = self.treasury_pointer().get();
if data.is_empty() { return Err(anyhow!("treasury not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn price_oracle(&self) -> Result<AlkaneId> {
let data = self.price_oracle_pointer().get();
if data.is_empty() { return Err(anyhow!("price oracle not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn discount_bps(&self) -> u128 {
let stored = self.discount_bps_pointer().get_value::<u128>();
if stored == 0 { DEFAULT_DISCOUNT_BPS } else { stored }
}
fn vesting_period(&self) -> u64 {
let stored = self.vesting_period_pointer().get_value::<u64>();
if stored == 0 { DEFAULT_VESTING_PERIOD } else { stored }
}
fn is_paused(&self) -> bool {
self.paused_pointer().get_value::<u128>() != 0
}
fn bond_position_template(&self) -> u128 {
self.bond_position_template_pointer().get_value::<u128>()
}
fn bond_count(&self) -> u128 {
self.bond_count_pointer().get_value::<u128>()
}
fn genesis_height(&self) -> u64 {
self.genesis_height_pointer().get_value::<u64>()
}
fn halving_epoch(&self) -> u128 {
self.halving_epoch_pointer().get_value::<u128>()
}
fn epoch_start(&self) -> u64 {
self.epoch_start_pointer().get_value::<u64>()
}
fn total_bonded_fire(&self) -> u128 {
self.total_bonded_fire_pointer().get_value::<u128>()
}
/// Current bonding emission rate (halves each epoch)
fn current_emission_rate(&self) -> u128 {
get_emission_rate_for_epoch(BONDING_EMISSION_RATE, self.halving_epoch())
}
/// Check and update epoch. Resets total_bonded_fire on epoch change.
fn check_epoch(&self, current_height: u64) {
let genesis = self.genesis_height();
let elapsed = current_height.saturating_sub(genesis);
let calculated_epoch = (elapsed / HALVING_INTERVAL) as u128;
let stored_epoch = self.halving_epoch();
if calculated_epoch > stored_epoch {
// New epoch — update state
let boundary = genesis + (calculated_epoch as u64) * HALVING_INTERVAL;
self.halving_epoch_pointer().set_value(calculated_epoch);
self.epoch_start_pointer().set_value::<u64>(boundary);
// Reset bonded counter — new epoch starts fresh
self.total_bonded_fire_pointer().set_value(0u128);
}
}
/// How much FIRE has been unlocked since epoch_start at current rate
fn unlocked_fire(&self, current_height: u64) -> u128 {
let elapsed = (current_height as u128).saturating_sub(self.epoch_start() as u128);
self.current_emission_rate() * elapsed
}
/// Available bonding capacity right now
fn available_capacity(&self, current_height: u64) -> u128 {
self.unlocked_fire(current_height).saturating_sub(self.total_bonded_fire())
}
// ============ Child Registration ============
fn register_child(&self, id: &AlkaneId) {
self.child_registered_pointer(id).set_value(1u128);
}
fn is_registered_child(&self, id: &AlkaneId) -> bool {
self.child_registered_pointer(id).get_value::<u128>() == 1
}
// ============ Position Token Helpers ============
fn authenticate_bond_position(&self, incoming: &[AlkaneTransfer], target: &AlkaneId) -> Result<AlkaneId> {
let transfer = if target.block == 0 && target.tx == 0 {
incoming.iter()
.find(|t| t.value >= 1 && self.is_registered_child(&t.id))
} else {
incoming.iter()
.find(|t| t.value >= 1 && t.id == *target && self.is_registered_child(&t.id))
};
let transfer = transfer
.ok_or_else(|| anyhow!("no registered bond position token in incoming alkanes"))?;
Ok(transfer.id.clone())
}
fn read_bond_position(&self, token_id: &AlkaneId) -> Result<(u128, u128, u128, u128, u128)> {
let cellpack = Cellpack {
target: token_id.clone(),
inputs: vec![BOND_POS_GET_ALL_DETAILS],
};
let response = self.staticcall(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
if response.data.len() < 80 {
return Err(anyhow!(
"bond position returned {} bytes, expected 80",
response.data.len()
));
}
let read = |offset: usize| -> Result<u128> {
Ok(u128::from_le_bytes(
response.data[offset..offset + 16]
.try_into()
.map_err(|_| anyhow!("parse error at offset {}", offset))?,
))
};
Ok((read(0)?, read(16)?, read(32)?, read(48)?, read(64)?))
}
fn update_bond_claimed(&self, token_id: &AlkaneId, new_claimed: u128) -> Result<()> {
let cellpack = Cellpack {
target: token_id.clone(),
inputs: vec![BOND_POS_SET_CLAIMED, new_claimed],
};
self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
Ok(())
}
// ============ Pricing Helpers ============
fn query_fire_price(&self) -> Result<u128> {
let oracle = self.price_oracle()?;
let cellpack = Cellpack {
target: oracle,
inputs: vec![0],
};
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().unwrap()))
} else {
Err(anyhow!("oracle returned no price data"))
}
}
fn record_purchase_on_oracle(&self, lp_amount: u128) -> Result<()> {
let oracle = self.price_oracle()?;
let cellpack = Cellpack {
target: oracle,
inputs: vec![1, lp_amount],
};
self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
Ok(())
}
fn query_floor_price(&self) -> Result<u128> {
let treasury = self.treasury()?;
let cellpack = Cellpack {
target: treasury,
inputs: vec![23], // GetRedemptionRate
};
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().unwrap()))
} else {
Err(anyhow!("treasury returned no floor price data"))
}
}
fn calculate_fire_for_lp(&self, lp_amount: u128) -> Result<u128> {
let oracle_price = self.query_fire_price()?;
let floor_price = self.query_floor_price()?;
let discount = self.discount_bps();
let oracle_discounted = if oracle_price > 0 {
(oracle_price * (10000 - discount)) / 10000
} else {
0
};
let effective_price = if oracle_discounted > floor_price {
oracle_discounted
} else {
floor_price
};
if effective_price == 0 {
return Err(anyhow!("effective bond price is zero"));
}
let fire_amount = (lp_amount * DECIMAL_FACTOR) / effective_price;
Ok(fire_amount)
}
fn calculate_vested_from_position(
&self,
fire_amount: u128,
start_time: u128,
end_time: u128,
claimed: u128,
current_height: u64,
) -> u128 {
let now = current_height as u128;
if fire_amount == 0 || now <= start_time {
return 0;
}
let total_vested = if now >= end_time {
fire_amount
} else {
let elapsed = now - start_time;
let duration = end_time - start_time;
if duration == 0 { fire_amount } else { (fire_amount * elapsed) / duration }
};
total_vested.saturating_sub(claimed)
}
// ============ Message Handlers ============
fn initialize(
&self,
fire_token: AlkaneId,
diesel_lp_token: AlkaneId,
treasury: AlkaneId,
price_oracle: AlkaneId,
bond_position_template: u128,
genesis_height: u128,
) -> Result<CallResponse> {
if self.auth_token_pointer().get().len() > 0 {
self.only_owner()?;
}
self.observe_initialization()?;
let current_height = self.height();
// genesis_height=0 → use ACTIVATION_BLOCK constant (mainnet default)
let effective_genesis = if genesis_height > 0 { genesis_height as u64 } else { ACTIVATION_BLOCK };
// Calculate initial epoch from genesis
let initial_epoch = ((current_height.saturating_sub(effective_genesis)) / HALVING_INTERVAL) as u128;
let epoch_boundary = effective_genesis + (initial_epoch as u64) * HALVING_INTERVAL;
self.fire_token_pointer().set(Arc::new(fire_token.into()));
self.diesel_lp_token_pointer().set(Arc::new(diesel_lp_token.into()));
self.treasury_pointer().set(Arc::new(treasury.into()));
self.price_oracle_pointer().set(Arc::new(price_oracle.into()));
self.bond_position_template_pointer().set_value(bond_position_template);
self.genesis_height_pointer().set_value::<u64>(effective_genesis);
self.halving_epoch_pointer().set_value(initial_epoch);
// Use current_height, not epoch_boundary — otherwise capacity for all
// blocks between epoch_boundary and deploy height is available instantly.
self.epoch_start_pointer().set_value::<u64>(current_height);
self.discount_bps_pointer().set_value(DEFAULT_DISCOUNT_BPS);
self.vesting_period_pointer().set_value(DEFAULT_VESTING_PERIOD);
self.bond_count_pointer().set_value(0u128);
self.total_bonded_fire_pointer().set_value(0u128);
self.total_claimed_fire_pointer().set_value(0u128);
self.total_bonded_lp_pointer().set_value(0u128);
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
if self.auth_token_pointer().get().len() == 0 {
response.alkanes.0.push(self.deploy_auth_token(1)?);
}
Ok(response)
}
fn bond(&self, lp_to_bond: u128, min_fire_out: u128) -> Result<CallResponse> {
if self.is_paused() {
return Err(anyhow!("bonding is paused"));
}
let context = self.context()?;
let current_height = self.height();
let diesel_lp = self.diesel_lp_token()?;
let treasury = self.treasury()?;
// Check epoch — may halve rate and reset bonded counter
self.check_epoch(current_height);
// Find LP tokens in incoming
let lp_transfer = context
.incoming_alkanes
.0
.iter()
.find(|t| t.id == diesel_lp)
.ok_or_else(|| anyhow!("no LP tokens sent"))?;
let lp_incoming = lp_transfer.value;
// lp_to_bond=0 means bond all incoming LP
let bond_amount = if lp_to_bond == 0 { lp_incoming } else { lp_to_bond };
if bond_amount == 0 {
return Err(anyhow!("zero LP amount"));
}
if bond_amount > lp_incoming {
return Err(anyhow!("requested {} LP but only {} sent", bond_amount, lp_incoming));
}
let lp_change = lp_incoming - bond_amount;
// Calculate FIRE amount from price
let fire_amount = self.calculate_fire_for_lp(bond_amount)?;
if fire_amount == 0 {
return Err(anyhow!("bond would yield zero FIRE — price too high or LP too small"));
}
// Slippage protection
if min_fire_out > 0 && fire_amount < min_fire_out {
return Err(anyhow!(
"slippage: would receive {} FIRE, minimum requested {}",
fire_amount, min_fire_out
));
}
// Check capacity: linear unlock rate-limits bonding
let available = self.available_capacity(current_height);
if fire_amount > available {
return Err(anyhow!(
"exceeds available bond capacity: requested {}, available {}",
fire_amount, available
));
}
// Record purchase on oracle (no-op in staking-based oracle)
self.record_purchase_on_oracle(bond_amount)?;
// Mint FIRE from bonding emission pool
let fire_token = self.fire_token()?;
let mint_cellpack = Cellpack {
target: fire_token,
inputs: vec![FIRE_MINT_BONDING_OPCODE, fire_amount],
};
self.call(&mint_cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
// Update totals
let bonded_fire = self.total_bonded_fire();
self.total_bonded_fire_pointer().set_value(bonded_fire + fire_amount);
let bonded_lp = self.total_bonded_lp_pointer().get_value::<u128>();
self.total_bonded_lp_pointer().set_value(bonded_lp + bond_amount);
// Create bond position token via factory clone
let bond_id = self.bond_count();
let end_time = (current_height as u128) + (self.vesting_period() as u128);
let template = self.bond_position_template();
let cellpack = Cellpack {
target: AlkaneId { block: 6, tx: template },
inputs: vec![
0u128, // Initialize opcode on bond position token
bond_id,
fire_amount,
current_height as u128,
end_time,
],
};
let create_response = self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
if create_response.alkanes.0.is_empty() {
return Err(anyhow!("bond position token not returned from factory create"));
}
let position_token = &create_response.alkanes.0[0];
// Register and increment count
self.register_child(&position_token.id);
self.bond_count_pointer().set_value(bond_id + 1);
// Transfer LP to treasury (only the bonded amount)
let treasury_cellpack = Cellpack {
target: treasury,
inputs: vec![10], // Deposit
};
let parcel = AlkaneTransferParcel(vec![AlkaneTransfer {
id: diesel_lp.clone(),
value: bond_amount,
}]);
self.call(&treasury_cellpack, &parcel, self.fuel())?;
// Return position token + LP change + non-LP incoming
let mut response = CallResponse::default();
response.alkanes.0.push(position_token.clone());
if lp_change > 0 {
response.alkanes.0.push(AlkaneTransfer { id: diesel_lp.clone(), value: lp_change });
}
for transfer in &context.incoming_alkanes.0 {
if transfer.id != diesel_lp {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
fn claim_vested(&self, target_position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
let fire_token = self.fire_token()?;
// Authenticate position token
let pos_token_id = self.authenticate_bond_position(&context.incoming_alkanes.0, &target_position)?;
// Read bond data from position token
let (_, fire_amount, start_time, end_time, claimed) =
self.read_bond_position(&pos_token_id)?;
let claimable = self.calculate_vested_from_position(
fire_amount, start_time, end_time, claimed, current_height,
);
if claimable == 0 {
return Ok(CallResponse::forward(&context.incoming_alkanes));
}
// Update claimed on position token
self.update_bond_claimed(&pos_token_id, claimed + claimable)?;
// Track total claimed for circulating supply calculation
let prev_claimed = self.total_claimed_fire_pointer().get_value::<u128>();
self.total_claimed_fire_pointer().set_value(prev_claimed + claimable);
// Build response: return position token + FIRE
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer {
id: pos_token_id.clone(),
value: 1u128,
});
response.alkanes.0.push(AlkaneTransfer {
id: fire_token,
value: claimable,
});
for transfer in &context.incoming_alkanes.0 {
if transfer.id != pos_token_id {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
// ============ Admin ============
fn set_discount(&self, discount_bps: u128) -> Result<CallResponse> {
self.only_owner()?;
if discount_bps > MAX_DISCOUNT_BPS {
return Err(anyhow!("discount exceeds maximum {}bps", MAX_DISCOUNT_BPS));
}
self.discount_bps_pointer().set_value(discount_bps);
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn set_paused(&self, paused: u128) -> Result<CallResponse> {
self.only_owner()?;
self.paused_pointer().set_value(paused);
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn set_price_oracle(&self, oracle: AlkaneId) -> Result<CallResponse> {
self.only_owner()?;
self.price_oracle_pointer().set(Arc::new(oracle.into()));
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
// ============ View Functions ============
fn get_current_discount(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.discount_bps().to_le_bytes().to_vec();
Ok(response)
}
fn get_fire_price(&self) -> Result<CallResponse> {
let context = self.context()?;
let price = self.query_fire_price()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = price.to_le_bytes().to_vec();
Ok(response)
}
fn get_available_capacity(&self) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
// Note: view doesn't mutate, so we calculate epoch inline
let genesis = self.genesis_height();
let elapsed = current_height.saturating_sub(genesis);
let calc_epoch = (elapsed / HALVING_INTERVAL) as u128;
let stored_epoch = self.halving_epoch();
let (rate, ep_start, bonded) = if calc_epoch > stored_epoch {
// Would be a new epoch — capacity from new epoch start
let boundary = genesis + (calc_epoch as u64) * HALVING_INTERVAL;
let rate = get_emission_rate_for_epoch(BONDING_EMISSION_RATE, calc_epoch);
(rate, boundary as u128, 0u128)
} else {
(self.current_emission_rate(), self.epoch_start() as u128, self.total_bonded_fire())
};
let ep_elapsed = (current_height as u128).saturating_sub(ep_start);
let available = (rate * ep_elapsed).saturating_sub(bonded);
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = available.to_le_bytes().to_vec();
Ok(response)
}
fn get_total_bonded_fire(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_bonded_fire().to_le_bytes().to_vec();
Ok(response)
}
fn get_current_halving_epoch(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.halving_epoch().to_le_bytes().to_vec();
Ok(response)
}
fn get_bond_position_template(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.bond_position_template().to_le_bytes().to_vec();
Ok(response)
}
fn get_bond_count(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.bond_count().to_le_bytes().to_vec();
Ok(response)
}
fn get_emission_rate(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.current_emission_rate().to_le_bytes().to_vec();
Ok(response)
}
fn get_total_claimed_fire(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_claimed_fire_pointer().get_value::<u128>().to_le_bytes().to_vec();
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = b"FIRE Bonding".to_vec();
Ok(response)
}
}
declare_alkane! {
impl AlkaneResponder for FireBonding {
type Message = FireBondingMessage;
}
}

Verified Source