Source – Alkane 2:88383 — SUBFROST Explorer

alkanes/fire-staking/src/lib.rs45,671 B

//! FIRE Staking Contract — wLP + NFT Position Architecture
//!
//! Timelocked LP staking with wLP (wrapped LP) fungible receipts.
//!
//! On Stake: LP → NFT (FIRE accrual) + wLP (LP claim)
//! Normal Unstake (before expiry): NFT + wLP → LP + FIRE
//! After expiry: wLP alone → LP (NFT no longer needed)
//! NFT → final FIRE claim (no more accrual)
//!
//! Expiry = next halving boundary (105,000 block intervals).
//! All positions share the same expiry. After halving, re-stake for new epoch.
//!
//! Synthetix accumulator with per-position checkpoints (NFT).
//! FIRE accrual capped at expiry block per position.
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::{
absolute_epoch, get_emission_rate_for_epoch, get_lock_multiplier,
MULTIPLIER_BASE, PRECISION, STAKING_EMISSION_RATE, HALVING_INTERVAL, SIX_MONTHS,
};
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use ruint::Uint;
use std::sync::Arc;
type U256 = Uint<256, 4>;
/// Opcode for minting from FIRE token's emission pool
const FIRE_MINT_OPCODE: u128 = 77;
/// Position token opcodes (must match fire-position-token MessageDispatch)
const POS_SET_REWARD_CHECKPOINT: u128 = 1;
const POS_GET_ALL_DETAILS: u128 = 23;
/// wLP token opcodes (fire-series-token)
const WLP_MINT: u128 = 10;
const WLP_BURN: u128 = 11;
#[derive(Default)]
pub struct FireStaking(());
impl AlkaneResponder for FireStaking {}
impl AuthenticatedResponder for FireStaking {}
#[derive(MessageDispatch)]
enum FireStakingMessage {
/// Initialize the staking contract
#[opcode(0)]
/// start_block: 0 = current height, >0 = explicit (stakes blocked until this block)
/// expiry_height: 0 = auto (next halving boundary - 1), >0 = explicit
/// halving_epoch: which halving epoch this contract represents (0, 1, 2...)
/// determines emission rate via get_emission_rate_for_epoch(base, halving_epoch)
/// position_beacon: beacon for position-token clones ({0,0} = direct template, legacy)
Initialize {
lp_token: AlkaneId,
fire_token: AlkaneId,
position_template: u128,
wlp_template: u128,
start_block: u128,
expiry_height: u128,
halving_epoch: u128,
position_beacon: AlkaneId,
},
/// Stake LP tokens. amount=0 stakes all incoming LP. Returns NFT (full position).
#[opcode(1)]
Stake { lock_duration: u128, amount: u128 },
/// Unstake full position: send NFT (with wLP inside). Returns LP + FIRE.
/// If NFT was split (wLP extracted), requires NFT + matching wLP.
/// target_position: AlkaneId of NFT to unstake ({0,0} = first found)
#[opcode(2)]
Unstake { target_position: AlkaneId },
/// Claim rewards: send NFT, get it back + FIRE.
/// target_position: AlkaneId of NFT to claim ({0,0} = first found)
#[opcode(3)]
ClaimRewards { target_position: AlkaneId },
/// Split: send NFT → get NFT back + wLP extracted.
/// After split, unstake requires NFT + wLP.
/// target_position: AlkaneId of NFT to split ({0,0} = first found)
#[opcode(4)]
Split { target_position: AlkaneId },
/// Merge: send NFT + wLP → get NFT back (full position restored).
/// target_position: AlkaneId of NFT to merge ({0,0} = first found)
#[opcode(5)]
Merge { target_position: AlkaneId },
/// Update epoch (anyone can call to trigger halving)
#[opcode(7)]
UpdateEpoch,
/// Redeem expired: send wLP after expiry, get LP back (no NFT needed).
#[opcode(8)]
RedeemExpired,
// ── View functions ─────────────────────────────────────────────
/// Get total staked LP tokens (weighted)
#[opcode(12)]
#[returns(u128)]
GetTotalStaked,
/// Get current epoch
#[opcode(14)]
#[returns(u128)]
GetCurrentEpoch,
/// Get current emission rate
#[opcode(15)]
#[returns(u128)]
GetCurrentEmissionRate,
/// Get expiry block for current epoch
#[opcode(16)]
#[returns(u128)]
GetExpiry,
/// Get wLP token AlkaneId (32 bytes)
#[opcode(17)]
#[returns(Vec<u8>)]
GetWlpToken,
/// Preview claimable FIRE for a position (view, no tx needed).
#[opcode(18)]
#[returns(u128)]
PreviewClaim { position_token: AlkaneId },
/// Get position template ID
#[opcode(30)]
#[returns(u128)]
GetPositionTemplate,
/// Get total positions ever created
#[opcode(31)]
#[returns(u128)]
GetPositionCount,
/// Get total actual LP locked (only positions with lock >= 6 months, for oracle)
#[opcode(33)]
#[returns(u128)]
GetTotalLockedLp,
/// Get total raw LP staked across all positions (no multiplier, no duration filter)
#[opcode(34)]
#[returns(u128)]
GetTotalRawStake,
/// Check if an AlkaneId is a registered child position token
#[opcode(36)]
#[returns(u128)]
IsRegisteredChild { child: AlkaneId },
/// Returns 1 if position has been split (wLP extracted), 0 otherwise
#[opcode(37)]
#[returns(u128)]
GetPositionSplitStatus { position: AlkaneId },
/// Get contract name
#[opcode(99)]
#[returns(String)]
GetName,
}
impl FireStaking {
// ============ Storage Pointers ============
fn lp_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/lp_token")
}
fn fire_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/fire_token")
}
fn position_template_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/position_template")
}
fn wlp_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/wlp_token")
}
fn expiry_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/expiry")
}
fn start_height_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/start_height")
}
fn current_epoch_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/current_epoch")
}
fn position_beacon_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/position_beacon")
}
fn total_weighted_stake_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_weighted_stake")
}
fn total_locked_lp_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_locked_lp")
}
fn total_raw_stake_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/total_raw_stake")
}
fn reward_per_token_stored_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/reward_per_token_stored")
}
fn last_update_height_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/last_update_height")
}
fn position_count_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/position_count")
}
// Registered children (position tokens)
fn children_count_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/children_count")
}
fn child_pointer(&self, index: u128) -> StoragePointer {
StoragePointer::from_keyword("/children/")
.select(&index.to_le_bytes().to_vec())
}
fn child_registered_pointer(&self, id: &AlkaneId) -> StoragePointer {
StoragePointer::from_keyword("/child_reg/")
.select(&<AlkaneId as Into<Vec<u8>>>::into(id.clone()))
}
/// Track whether a position has been split (wLP extracted)
fn position_split_pointer(&self, id: &AlkaneId) -> StoragePointer {
StoragePointer::from_keyword("/split/")
.select(&<AlkaneId as Into<Vec<u8>>>::into(id.clone()))
}
fn is_position_split(&self, id: &AlkaneId) -> bool {
self.position_split_pointer(id).get_value::<u128>() == 1
}
fn set_position_split(&self, id: &AlkaneId, split: bool) {
self.position_split_pointer(id).set_value(if split { 1u128 } else { 0u128 });
}
// ============ Getters ============
fn lp_token(&self) -> Result<AlkaneId> {
let data = self.lp_token_pointer().get();
if data.is_empty() {
return Err(anyhow!("LP token not set"));
}
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
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 position_template(&self) -> u128 {
self.position_template_pointer().get_value::<u128>()
}
fn wlp_token(&self) -> Result<AlkaneId> {
let data = self.wlp_token_pointer().get();
if data.is_empty() { return Err(anyhow!("wLP token not set")); }
Ok(AlkaneId::try_from(data.as_slice().to_vec())?)
}
fn expiry(&self) -> u128 {
self.expiry_pointer().get_value::<u128>()
}
fn start_height(&self) -> u64 {
self.start_height_pointer().get_value::<u64>()
}
fn current_epoch(&self) -> u128 {
self.current_epoch_pointer().get_value::<u128>()
}
fn total_weighted_stake(&self) -> u128 {
self.total_weighted_stake_pointer().get_value::<u128>()
}
fn total_locked_lp(&self) -> u128 {
self.total_locked_lp_pointer().get_value::<u128>()
}
fn total_raw_stake(&self) -> u128 {
self.total_raw_stake_pointer().get_value::<u128>()
}
fn reward_per_token_stored(&self) -> u128 {
self.reward_per_token_stored_pointer().get_value::<u128>()
}
fn last_update_height(&self) -> u64 {
self.last_update_height_pointer().get_value::<u64>()
}
fn position_count(&self) -> u128 {
self.position_count_pointer().get_value::<u128>()
}
// ============ Child Registration ============
fn register_child(&self, id: &AlkaneId) {
let count = self.children_count_pointer().get_value::<u128>();
self.child_pointer(count)
.set(Arc::new(id.clone().into()));
self.children_count_pointer().set_value(count + 1);
self.child_registered_pointer(id).set_value(1u128);
}
fn deregister_child(&self, id: &AlkaneId) {
self.child_registered_pointer(id).set_value(0u128);
}
fn is_registered_child_internal(&self, id: &AlkaneId) -> bool {
self.child_registered_pointer(id).get_value::<u128>() == 1
}
// ============ Core Logic (preserved from original) ============
fn current_emission_rate(&self) -> u128 {
get_emission_rate_for_epoch(STAKING_EMISSION_RATE, self.current_epoch())
}
/// Calculate reward per token based on time elapsed (UNCHANGED from original)
fn reward_per_token(&self, current_height: u64) -> u128 {
let total_stake = self.total_weighted_stake();
if total_stake == 0 {
return self.reward_per_token_stored();
}
let last_time = self.last_update_height();
let time_delta = current_height.saturating_sub(last_time) as u128;
let emission_rate = self.current_emission_rate();
let increment: u128 = (U256::from(emission_rate) * U256::from(time_delta) * U256::from(PRECISION)
/ U256::from(total_stake))
.try_into()
.unwrap_or(u128::MAX);
self.reward_per_token_stored().saturating_add(increment)
}
/// Effective height for reward calculations — capped at expiry.
fn effective_reward_height(&self, current_height: u64) -> u64 {
let expiry = self.expiry();
if expiry > 0 && (current_height as u128) > expiry {
expiry as u64
} else {
current_height
}
}
/// Update global reward state. Capped at expiry — no emission after expiry.
fn update_global_reward(&self, current_height: u64) {
let h = self.effective_reward_height(current_height);
let new_reward_per_token = self.reward_per_token(h);
self.reward_per_token_stored_pointer()
.set_value(new_reward_per_token);
self.last_update_height_pointer().set_value::<u64>(h);
}
/// Calculate earned rewards for a position token.
/// Uses capped height — consistent with update_global_reward.
fn earned_for_position(
&self,
weighted_amount: u128,
reward_checkpoint: u128,
current_height: u64,
) -> u128 {
let reward_per_token = self.reward_per_token(self.effective_reward_height(current_height));
let delta = reward_per_token.saturating_sub(reward_checkpoint);
(U256::from(weighted_amount) * U256::from(delta) / U256::from(PRECISION))
.try_into()
.unwrap_or(u128::MAX)
}
// check_epoch removed — in factory architecture, halving_epoch is fixed at init.
// Rate determined by halving_epoch from factory, never changes within a clone.
/// Mint FIRE from emission pool via the token contract (UNCHANGED from original)
fn mint_fire(&self, amount: u128) -> Result<CallResponse> {
let fire_token = self.fire_token()?;
let cellpack = Cellpack {
target: fire_token,
inputs: vec![FIRE_MINT_OPCODE, amount],
};
self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())
}
/// Authenticate a position token from incomingAlkanes.
/// Searches all incoming (not just first) for a registered child.
fn authenticate_position(&self, incoming: &[AlkaneTransfer], target: &AlkaneId) -> Result<AlkaneId> {
// If target is {0,0}, find first registered position (backward compat).
// Otherwise, find the specific position by ID.
let transfer = if target.block == 0 && target.tx == 0 {
incoming.iter()
.find(|t| t.value >= 1 && self.is_registered_child_internal(&t.id))
} else {
incoming.iter()
.find(|t| t.value >= 1 && t.id == *target && self.is_registered_child_internal(&t.id))
};
let transfer = transfer
.ok_or_else(|| anyhow!("no registered position token in incoming alkanes"))?;
Ok(transfer.id.clone())
}
/// Read all position data from a position token via staticcall opcode 23
/// Returns: (position_id, deposit_amount, weighted_amount, lock_end,
/// lock_duration, multiplier, reward_checkpoint)
fn read_position_token(
&self,
token_id: &AlkaneId,
) -> Result<(u128, u128, u128, u128, u128, u128, u128, AlkaneId)> {
let cellpack = Cellpack {
target: token_id.clone(),
inputs: vec![POS_GET_ALL_DETAILS],
};
let response =
self.staticcall(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
// Now 9 × u128 = 144 bytes (added deposit_token block + tx)
if response.data.len() < 144 {
return Err(anyhow!(
"position token returned {} bytes, expected 144",
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))?,
))
};
let deposit_token = AlkaneId {
block: read(112)?,
tx: read(128)?,
};
Ok((
read(0)?, // position_id
read(16)?, // deposit_amount
read(32)?, // weighted_amount
read(48)?, // lock_end
read(64)?, // lock_duration
read(80)?, // multiplier
read(96)?, // reward_checkpoint
deposit_token,
))
}
/// Update position token's reward checkpoint via call opcode 1
fn update_position_checkpoint(&self, token_id: &AlkaneId, new_checkpoint: u128) -> Result<()> {
let cellpack = Cellpack {
target: token_id.clone(),
inputs: vec![POS_SET_REWARD_CHECKPOINT, new_checkpoint],
};
self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
Ok(())
}
// ============ Message Handlers ============
fn initialize(
&self,
lp_token: AlkaneId,
fire_token: AlkaneId,
position_template: u128,
wlp_template: u128,
start_block: u128,
expiry_height: u128,
halving_epoch: u128,
position_beacon: AlkaneId,
) -> Result<CallResponse> {
self.observe_initialization()?;
let current_height = self.height();
let context = self.context()?;
// Start block: explicit or current height
let effective_start = if start_block > 0 { start_block as u64 } else { current_height };
self.lp_token_pointer()
.set(Arc::new(lp_token.into()));
self.fire_token_pointer()
.set(Arc::new(fire_token.into()));
self.position_template_pointer()
.set_value(position_template);
// Position-token beacon for upgradeable position-NFT logic.
// {0,0} = direct template clone (legacy / test harness).
if position_beacon.block != 0 || position_beacon.tx != 0 {
self.position_beacon_pointer().set(Arc::new(position_beacon.into()));
}
self.start_height_pointer().set_value::<u64>(effective_start);
// Set halving epoch — determines emission rate (halves each epoch)
self.current_epoch_pointer().set_value(halving_epoch);
self.total_weighted_stake_pointer().set_value(0u128);
self.reward_per_token_stored_pointer().set_value(0u128);
self.last_update_height_pointer().set_value::<u64>(effective_start);
self.position_count_pointer().set_value(0u128);
self.children_count_pointer().set_value(0u128);
self.total_locked_lp_pointer().set_value(0u128);
self.total_raw_stake_pointer().set_value(0u128);
// Set expiry: explicit or auto (last block before next halving boundary).
let expiry = if expiry_height > 0 {
expiry_height
} else {
(absolute_epoch(current_height) + 1) * HALVING_INTERVAL as u128 - 1
};
self.expiry_pointer().set_value(expiry);
// Create wLP fungible token via factory clone (block 6).
// series_id = halving_epoch → wLP for epoch N is named "FIRE-PT-N".
let wlp_seq = self.sequence();
self.call(
&Cellpack {
target: AlkaneId { block: 6, tx: wlp_template },
inputs: vec![
0, // Initialize opcode on fire-series-token
context.myself.block,
context.myself.tx,
halving_epoch, // series_id = epoch index
],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
let wlp_token = AlkaneId { block: 2, tx: wlp_seq };
self.wlp_token_pointer().set(Arc::new(wlp_token.into()));
Ok(CallResponse::default())
}
fn stake(&self, lock_duration: u128, amount: u128) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
let lp_token = self.lp_token()?;
// Cannot stake before start block (epoch not active yet)
let start = self.start_height() as u128;
if (current_height as u128) < start {
return Err(anyhow!("epoch not active yet (starts block {})", start));
}
// Cannot stake after expiry
let expiry = self.expiry();
if expiry > 0 && (current_height as u128) >= expiry {
return Err(anyhow!("staking period ended (expiry block {})", expiry));
}
// Lock cannot extend past expiry (checked_add prevents u128 overflow)
let lock_end = if lock_duration > 0 {
let le = (current_height as u128)
.checked_add(lock_duration)
.ok_or_else(|| anyhow!("lock_end overflow"))?;
if le > expiry {
return Err(anyhow!("lock_end {} exceeds expiry {}", le, expiry));
}
le
} else {
0
};
let lock_duration_u64 = u64::try_from(lock_duration)
.map_err(|_| anyhow!("lock_duration too large"))?;
// Find LP tokens in incoming alkanes
let lp_transfer = context.incoming_alkanes.0.iter()
.find(|t| t.id == lp_token)
.ok_or_else(|| anyhow!("LP token not found in incoming alkanes"))?;
let lp_incoming = lp_transfer.value;
// amount=0 means stake all incoming LP
let stake_amount = if amount == 0 { lp_incoming } else { amount };
if stake_amount == 0 {
return Err(anyhow!("cannot stake zero LP tokens"));
}
if stake_amount > lp_incoming {
return Err(anyhow!("requested {} but only {} LP sent", stake_amount, lp_incoming));
}
let lp_change = lp_incoming - stake_amount;
// Update global reward state (no check_epoch — halving_epoch fixed at init)
self.update_global_reward(current_height);
// Calculate multiplier based on lock duration
let multiplier = get_lock_multiplier(lock_duration_u64);
// U256 intermediate prevents overflow when stake_amount * multiplier
// exceeds u128 (only with absurd stake_amount but defensive).
let weighted_amount: u128 = (U256::from(stake_amount) * U256::from(multiplier)
/ U256::from(MULTIPLIER_BASE))
.try_into()
.map_err(|_| anyhow!("weighted_amount overflow"))?;
// Reward checkpoint = current global reward_per_token_stored
let reward_checkpoint = self.reward_per_token_stored();
// Update global totals (checked_add — refuse if total would overflow)
let new_total = self.total_weighted_stake()
.checked_add(weighted_amount)
.ok_or_else(|| anyhow!("total_weighted_stake overflow"))?;
self.total_weighted_stake_pointer().set_value(new_total);
// Track raw total LP across all positions (no multiplier, no duration filter)
let raw = self.total_raw_stake()
.checked_add(stake_amount)
.ok_or_else(|| anyhow!("total_raw_stake overflow"))?;
self.total_raw_stake_pointer().set_value(raw);
// Track actual locked LP (only positions with lock >= 6 months, for bond oracle pricing)
if lock_duration_u64 >= SIX_MONTHS {
let locked = self.total_locked_lp()
.checked_add(stake_amount)
.ok_or_else(|| anyhow!("total_locked_lp overflow"))?;
self.total_locked_lp_pointer().set_value(locked);
}
// Create position token. Two-step when behind beacon proxy:
// Step 1: CREATECHILD from template → beacon-proxy clone in block 2.
// Use opcode 36863 (forward) for beacon-proxy templates; opcode 99
// (GetName) for direct templates (legacy).
// Step 2: Initialize beacon-proxy with our beacon ref (opcode 32767).
// Step 3: Business init (opcode 0) with position metadata.
let pos_id = self.position_count();
let template = self.position_template();
let pos_beacon_data = self.position_beacon_pointer().get();
let pos_beacon = if pos_beacon_data.is_empty() {
AlkaneId { block: 0, tx: 0 }
} else {
AlkaneId::try_from(pos_beacon_data.as_slice().to_vec())
.unwrap_or(AlkaneId { block: 0, tx: 0 })
};
let has_beacon = pos_beacon.block != 0 || pos_beacon.tx != 0;
let epoch_id = self.current_epoch_pointer().get_value::<u128>();
let position_token = if has_beacon {
// Step 1: clone template as beacon-proxy. Opcode 36863 = Forward (no-op).
let clone_seq = self.sequence();
self.call(
&Cellpack {
target: AlkaneId { block: 6, tx: template },
inputs: vec![36863],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
let pos_token_id = AlkaneId { block: 2, tx: clone_seq };
// Step 2: initialize beacon-proxy with beacon AlkaneId.
self.call(
&Cellpack {
target: pos_token_id.clone(),
inputs: vec![32767, pos_beacon.block, pos_beacon.tx],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
// Step 3: business init via beacon-proxy → delegatecall to position-impl.
let init_response = self.call(
&Cellpack {
target: pos_token_id.clone(),
inputs: vec![
0u128, // Initialize opcode on position token impl
pos_id,
stake_amount,
weighted_amount,
lock_end,
lock_duration as u128,
multiplier,
reward_checkpoint,
lp_token.block,
lp_token.tx,
epoch_id,
],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
if init_response.alkanes.0.is_empty() {
return Err(anyhow!("position token not returned from beacon-proxy init"));
}
init_response.alkanes.0[0].clone()
} else {
// Direct template path (legacy / tests): single CREATECHILD with business init.
let cellpack = Cellpack {
target: AlkaneId { block: 6, tx: template },
inputs: vec![
0u128,
pos_id,
stake_amount,
weighted_amount,
lock_end,
lock_duration as u128,
multiplier,
reward_checkpoint,
lp_token.block,
lp_token.tx,
epoch_id,
],
};
let create_response =
self.call(&cellpack, &AlkaneTransferParcel::default(), self.fuel())?;
if create_response.alkanes.0.is_empty() {
return Err(anyhow!("position token not returned from factory create"));
}
create_response.alkanes.0[0].clone()
};
// Bind everything below to `&position_token`
let position_token = &position_token;
// Register position token as child (not split initially)
self.register_child(&position_token.id);
self.set_position_split(&position_token.id, false);
self.position_count_pointer().set_value(pos_id + 1);
// Build response: return NFT + LP change + other tokens
let mut response = CallResponse::default();
response.alkanes.0.push(position_token.clone());
// Return LP change if any
if lp_change > 0 {
response.alkanes.0.push(AlkaneTransfer { id: lp_token, value: lp_change });
}
// Forward non-LP incoming
for transfer in &context.incoming_alkanes.0 {
if transfer.id != lp_token {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
fn unstake(&self, target_position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
// Authenticate position token
let pos_token_id = self.authenticate_position(&context.incoming_alkanes.0, &target_position)?;
// Read position data from token — includes deposit_token for exact refund
let (_, deposit_amount, weighted_amount, lock_end, lock_duration, _, reward_checkpoint, deposit_token) =
self.read_position_token(&pos_token_id)?;
// Check lock expired
if lock_end > 0 && (current_height as u128) < lock_end {
return Err(anyhow!("position still locked until {}", lock_end));
}
// If position was split, require matching wLP to reassemble
let is_split = self.is_position_split(&pos_token_id);
let mut wlp_excess: u128 = 0;
if is_split {
let wlp = self.wlp_token()?;
let wlp_transfer = context.incoming_alkanes.0.iter()
.find(|t| t.id == wlp)
.ok_or_else(|| anyhow!("position split: wLP not found in incoming"))?;
if wlp_transfer.value < deposit_amount {
return Err(anyhow!("position split: need {} wLP, got {}", deposit_amount, wlp_transfer.value));
}
wlp_excess = wlp_transfer.value - deposit_amount;
// Burn wLP (only deposit_amount, return excess)
self.call(
&Cellpack { target: wlp.clone(), inputs: vec![WLP_BURN, deposit_amount] },
&AlkaneTransferParcel::default(), self.fuel(),
)?;
}
// Update global reward state (no check_epoch — halving_epoch fixed at init)
self.update_global_reward(current_height);
// Calculate earned rewards for this position
let total_pending = self.earned_for_position(
weighted_amount,
reward_checkpoint,
current_height,
);
// Update global state
let current_total = self.total_weighted_stake();
self.total_weighted_stake_pointer()
.set_value(current_total.saturating_sub(weighted_amount));
// Decrement raw total LP
let raw = self.total_raw_stake();
self.total_raw_stake_pointer().set_value(raw.saturating_sub(deposit_amount));
// Decrement locked LP tracker if this was a long-locked position (>= 6 months)
if lock_duration >= SIX_MONTHS as u128 {
let locked = self.total_locked_lp();
self.total_locked_lp_pointer().set_value(locked.saturating_sub(deposit_amount));
}
// Deregister position token (consumed — user sent it in, won't get it back)
self.deregister_child(&pos_token_id);
// Build response: return LP + FIRE rewards
// Forward any unrelated incoming alkanes (except the position token)
let mut response = CallResponse::default();
// Return LP tokens — using deposit_token from position token (not self.lp_token())
response.alkanes.0.push(AlkaneTransfer {
id: deposit_token,
value: deposit_amount,
});
// Mint and return FIRE rewards if any
if total_pending > 0 {
let mint_response = self.mint_fire(total_pending)?;
for transfer in mint_response.alkanes.0 {
response.alkanes.0.push(transfer);
}
}
// Return excess wLP if any
if wlp_excess > 0 {
if let Ok(wlp) = self.wlp_token() {
response.alkanes.0.push(AlkaneTransfer { id: wlp, value: wlp_excess });
}
}
// Forward non-consumed incoming alkanes
let wlp_id = if is_split { self.wlp_token().ok() } else { None };
for transfer in &context.incoming_alkanes.0 {
if transfer.id == pos_token_id { continue; }
if let Some(ref wid) = wlp_id { if transfer.id == *wid { continue; } }
response.alkanes.0.push(transfer.clone());
}
Ok(response)
}
fn claim_rewards(&self, target_position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
// Authenticate position token
let pos_token_id = self.authenticate_position(&context.incoming_alkanes.0, &target_position)?;
// Read position data from token
let (_, deposit_amount, weighted_amount, _, lock_duration_claim, _, reward_checkpoint, deposit_token) =
self.read_position_token(&pos_token_id)?;
// Update global reward state (no check_epoch — halving_epoch fixed at init)
self.update_global_reward(current_height);
// Calculate earned rewards for this position
let total_pending = self.earned_for_position(
weighted_amount,
reward_checkpoint,
current_height,
);
let expiry = self.expiry();
let is_expired = expiry > 0 && (current_height as u128) >= expiry;
if is_expired {
// ── Post-expiry: auto-unstake behavior ──
// NFT consumed. Weight removed. FIRE paid.
// If not split: LP returned (auto-unstake).
// If split: LP stays (wLP holder redeems via RedeemExpired).
let current_total = self.total_weighted_stake();
self.total_weighted_stake_pointer()
.set_value(current_total.saturating_sub(weighted_amount));
// Decrement raw total LP
let raw = self.total_raw_stake();
self.total_raw_stake_pointer().set_value(raw.saturating_sub(deposit_amount));
// Decrement locked LP tracker if this was a long-locked position (>= 6 months)
if lock_duration_claim >= SIX_MONTHS as u128 {
let locked = self.total_locked_lp();
self.total_locked_lp_pointer().set_value(locked.saturating_sub(deposit_amount));
}
self.deregister_child(&pos_token_id);
let mut response = CallResponse::default();
// Mint and return FIRE (even if 0 — covers case of second call which reverts on deregister)
if total_pending > 0 {
let mint_resp = self.mint_fire(total_pending)?;
for t in mint_resp.alkanes.0 { response.alkanes.0.push(t); }
}
// If not split, return LP (auto-unstake to prevent LP loss)
let is_split = self.is_position_split(&pos_token_id);
if !is_split {
response.alkanes.0.push(AlkaneTransfer {
id: deposit_token,
value: deposit_amount,
});
}
// Forward non-NFT incoming
for transfer in &context.incoming_alkanes.0 {
if transfer.id != pos_token_id {
response.alkanes.0.push(transfer.clone());
}
}
return Ok(response);
}
// ── Normal claim (before expiry) ──
if total_pending == 0 {
let response = CallResponse::forward(&context.incoming_alkanes);
return Ok(response);
}
let new_checkpoint = self.reward_per_token_stored();
self.update_position_checkpoint(&pos_token_id, new_checkpoint)?;
let mint_response = self.mint_fire(total_pending)?;
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer {
id: pos_token_id.clone(),
value: 1u128,
});
for transfer in mint_response.alkanes.0 {
response.alkanes.0.push(transfer);
}
for transfer in &context.incoming_alkanes.0 {
if transfer.id != pos_token_id {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
/// Split: extract wLP from NFT position. NFT becomes FIRE-only claim.
fn split(&self, target_position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let pos_token_id = self.authenticate_position(&context.incoming_alkanes.0, &target_position)?;
if self.is_position_split(&pos_token_id) {
return Err(anyhow!("position already split"));
}
// Read deposit amount to know how much wLP to mint
let (_, deposit_amount, _, _, _, _, _, _) = self.read_position_token(&pos_token_id)?;
// Mint wLP
let wlp = self.wlp_token()?;
let wlp_resp = self.call(
&Cellpack { target: wlp.clone(), inputs: vec![WLP_MINT, deposit_amount] },
&AlkaneTransferParcel::default(), self.fuel(),
)?;
// Mark as split
self.set_position_split(&pos_token_id, true);
// Return NFT + wLP
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer { id: pos_token_id.clone(), value: 1 });
for t in wlp_resp.alkanes.0 { response.alkanes.0.push(t); }
for transfer in &context.incoming_alkanes.0 {
if transfer.id != pos_token_id { response.alkanes.0.push(transfer.clone()); }
}
Ok(response)
}
/// Merge: put wLP back into NFT. Restores full position.
fn merge(&self, target_position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let pos_token_id = self.authenticate_position(&context.incoming_alkanes.0, &target_position)?;
if !self.is_position_split(&pos_token_id) {
return Err(anyhow!("position not split"));
}
let (_, deposit_amount, _, _, _, _, _, _) = self.read_position_token(&pos_token_id)?;
// Require matching wLP
let wlp = self.wlp_token()?;
let wlp_transfer = context.incoming_alkanes.0.iter()
.find(|t| t.id == wlp)
.ok_or_else(|| anyhow!("wLP not found in incoming"))?;
let wlp_amount = wlp_transfer.value;
if wlp_amount < deposit_amount {
return Err(anyhow!("need {} wLP to merge, got {}", deposit_amount, wlp_amount));
}
// Burn wLP
self.call(
&Cellpack { target: wlp.clone(), inputs: vec![WLP_BURN, deposit_amount] },
&AlkaneTransferParcel::default(), self.fuel(),
)?;
// Mark as not split
self.set_position_split(&pos_token_id, false);
// Return NFT (full position restored) + excess wLP if any
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer { id: pos_token_id.clone(), value: 1 });
if wlp_amount > deposit_amount {
response.alkanes.0.push(AlkaneTransfer { id: wlp.clone(), value: wlp_amount - deposit_amount });
}
for transfer in &context.incoming_alkanes.0 {
if transfer.id != pos_token_id && transfer.id != wlp {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
fn update_epoch(&self) -> Result<CallResponse> {
let context = self.context()?;
let current_height = self.height();
self.update_global_reward(current_height);
// check_epoch removed — halving_epoch fixed at init in factory architecture
Ok(CallResponse::forward(&context.incoming_alkanes))
}
/// Redeem expired: burn wLP after expiry → get LP back (no NFT needed).
fn redeem_expired(&self) -> Result<CallResponse> {
let context = self.context()?;
let expiry = self.expiry();
if (self.height() as u128) < expiry {
return Err(anyhow!("not expired yet (expiry block {})", expiry));
}
// Find wLP in incoming
let wlp = self.wlp_token()?;
let wlp_transfer = context.incoming_alkanes.0.iter()
.find(|t| t.id == wlp)
.ok_or_else(|| anyhow!("no wLP tokens sent"))?;
let wlp_amount = wlp_transfer.value;
// Burn wLP
self.call(
&Cellpack { target: wlp.clone(), inputs: vec![WLP_BURN, wlp_amount] },
&AlkaneTransferParcel::default(), self.fuel(),
)?;
// Note: total_locked_lp is NOT decremented here.
// It is decremented in claim_rewards (post-expiry) and unstake when NFT is consumed.
// wLP is fungible and doesn't encode lock_duration, so decrementing here
// would cause double-decrement for split positions (claim + redeem both decrement).
// Return LP 1:1
let lp_token = self.lp_token()?;
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer { id: lp_token, value: wlp_amount });
for transfer in &context.incoming_alkanes.0 {
if transfer.id != wlp {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
// ============ View Functions ============
fn get_total_staked(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_weighted_stake().to_le_bytes().to_vec();
Ok(response)
}
fn get_current_epoch(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.current_epoch().to_le_bytes().to_vec();
Ok(response)
}
fn get_current_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 preview_claim(&self, position_token: AlkaneId) -> Result<CallResponse> {
if !self.is_registered_child_internal(&position_token) {
return Err(anyhow!("not a registered position"));
}
let (_, _, weighted_amount, _, _, _, reward_checkpoint, _) =
self.read_position_token(&position_token)?;
let claimable = self.earned_for_position(
weighted_amount,
reward_checkpoint,
self.height(),
);
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = claimable.to_le_bytes().to_vec();
Ok(response)
}
fn get_position_template(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.position_template().to_le_bytes().to_vec();
Ok(response)
}
fn get_position_count(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.position_count().to_le_bytes().to_vec();
Ok(response)
}
fn get_total_locked_lp(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_locked_lp().to_le_bytes().to_vec();
Ok(response)
}
fn get_total_raw_stake(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_raw_stake().to_le_bytes().to_vec();
Ok(response)
}
fn is_registered_child(&self, child: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let registered = self.is_registered_child_internal(&child);
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = (if registered { 1u128 } else { 0u128 })
.to_le_bytes()
.to_vec();
Ok(response)
}
fn get_position_split_status(&self, position: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
let split = self.is_position_split(&position);
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = (if split { 1u128 } else { 0u128 }).to_le_bytes().to_vec();
Ok(response)
}
fn get_expiry(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.expiry().to_le_bytes().to_vec();
Ok(response)
}
fn get_wlp_token(&self) -> Result<CallResponse> {
let wlp = self.wlp_token()?;
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data.extend_from_slice(&wlp.block.to_le_bytes());
response.data.extend_from_slice(&wlp.tx.to_le_bytes());
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = "FIRE Staking".as_bytes().to_vec();
Ok(response)
}
}
declare_alkane! {
impl AlkaneResponder for FireStaking {
type Message = FireStakingMessage;
}
}

Verified Source