Source – Alkane 2:87165 — SUBFROST Explorer

alkanes/fire-staking-factory/src/lib.rs17,750 B

//! FIRE Staking Factory — Epoch Manager
//!
//! Single permanent contract that manages staking epochs.
//! Each epoch is a fire-staking contract clone (block 6) with its own
//! wLP token, positions, and accumulator.
//!
//! Epochs align with FIRE halving boundaries (105,000 blocks).
//! AdvanceEpoch creates the next epoch clone — permissionless, anyone can call.
//!
//! Factory stores: epoch registry, templates, LP/FIRE token references.
//! Each epoch clone is self-contained (accumulator, positions, wLP).
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::AlkaneTransferParcel,
response::CallResponse,
};
use anyhow::{anyhow, Result};
use fire_support::{ACTIVATION_BLOCK, HALVING_INTERVAL};
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
#[derive(Default)]
pub struct FireStakingFactory(());
impl AlkaneResponder for FireStakingFactory {}
impl AuthenticatedResponder for FireStakingFactory {}
#[derive(MessageDispatch)]
enum FireStakingFactoryMessage {
/// Initialize factory with all template references.
/// epoch_duration hardcoded to HALVING_INTERVAL (105,000).
/// activation_block: 0 = use ACTIVATION_BLOCK constant (mainnet).
/// >0 = override (devnet/regtest).
/// beacon_id: staking beacon ({0,0} = direct template).
/// position_beacon: position-token beacon (passed through to each staking
/// clone so position-NFT logic is upgradeable). {0,0} = direct template.
#[opcode(0)]
Initialize {
lp_token: AlkaneId,
fire_token: AlkaneId,
staking_template: u128,
position_template: u128,
wlp_template: u128,
activation_block: u128,
beacon_id: AlkaneId,
position_beacon: AlkaneId,
},
/// Create next epoch. Permissionless — anyone can call anytime.
/// Epoch won't accept stakes until its start block is reached.
/// One epoch per halving period.
#[opcode(1)]
CreateNextEpoch,
// ── Views ──────────────────────────────────────────────────────
/// Get total number of epochs created
#[opcode(10)]
#[returns(u128)]
GetEpochCount,
/// Get staking contract AlkaneId for an epoch (32 bytes)
#[opcode(11)]
#[returns(Vec<u8>)]
GetEpochContract { epoch_index: u128 },
/// Get current active epoch index
#[opcode(12)]
#[returns(u128)]
GetCurrentEpochIndex,
/// Get LP token AlkaneId
#[opcode(13)]
#[returns(Vec<u8>)]
GetLpToken,
/// Get FIRE token AlkaneId
#[opcode(14)]
#[returns(Vec<u8>)]
GetFireToken,
/// Safe deploy opcode for CREATERESERVED
#[opcode(99)]
#[returns(String)]
GetName,
}
impl FireStakingFactory {
// ── Storage ───────────────────────────────────────────────────
fn lp_token_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/lp") }
fn fire_token_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/ft") }
fn staking_template_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/st") }
fn position_template_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/pt") }
fn wlp_template_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/wt") }
fn epoch_duration_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/ed") }
fn epoch_count_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/ec") }
fn beacon_id_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/bi") }
fn position_beacon_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/pbi") }
fn activation_block_pointer(&self) -> StoragePointer { StoragePointer::from_keyword("/ab") }
fn epoch_contract_pointer(&self, index: u128) -> StoragePointer {
StoragePointer::from_keyword("/e/")
.select(&index.to_le_bytes().to_vec())
}
fn epoch_absolute_pointer(&self, abs_epoch: u128) -> StoragePointer {
StoragePointer::from_keyword("/ea/")
.select(&abs_epoch.to_le_bytes().to_vec())
}
/// Store which absolute epoch each index maps to
fn epoch_abs_id_pointer(&self, index: u128) -> StoragePointer {
StoragePointer::from_keyword("/eai/")
.select(&index.to_le_bytes().to_vec())
}
// ── Getters ───────────────────────────────────────────────────
fn lp_token(&self) -> Result<AlkaneId> {
let d = self.lp_token_pointer().get();
if d.is_empty() { return Err(anyhow!("not initialized")); }
Ok(AlkaneId::try_from(d.as_slice().to_vec())?)
}
fn fire_token(&self) -> Result<AlkaneId> {
let d = self.fire_token_pointer().get();
if d.is_empty() { return Err(anyhow!("not initialized")); }
Ok(AlkaneId::try_from(d.as_slice().to_vec())?)
}
fn staking_template(&self) -> u128 { self.staking_template_pointer().get_value::<u128>() }
fn position_template(&self) -> u128 { self.position_template_pointer().get_value::<u128>() }
fn wlp_template(&self) -> u128 { self.wlp_template_pointer().get_value::<u128>() }
fn epoch_duration(&self) -> u128 { self.epoch_duration_pointer().get_value::<u128>() }
fn epoch_count(&self) -> u128 { self.epoch_count_pointer().get_value::<u128>() }
fn activation(&self) -> u128 {
let stored = self.activation_block_pointer().get_value::<u128>();
if stored > 0 { stored } else { ACTIVATION_BLOCK as u128 }
}
/// Beacon ID for staking clones. {0,0} = no beacon (direct template).
fn beacon_id(&self) -> AlkaneId {
let d = self.beacon_id_pointer().get();
if d.is_empty() { return AlkaneId { block: 0, tx: 0 }; }
AlkaneId::try_from(d.as_slice().to_vec()).unwrap_or(AlkaneId { block: 0, tx: 0 })
}
fn has_beacon(&self) -> bool {
let b = self.beacon_id();
b.block != 0 || b.tx != 0
}
/// Beacon ID for position-token clones. {0,0} = no beacon (direct template).
/// Passed through to each staking clone so position-NFT logic is upgradeable.
fn position_beacon(&self) -> AlkaneId {
let d = self.position_beacon_pointer().get();
if d.is_empty() { return AlkaneId { block: 0, tx: 0 }; }
AlkaneId::try_from(d.as_slice().to_vec()).unwrap_or(AlkaneId { block: 0, tx: 0 })
}
fn get_epoch_contract_id(&self, index: u128) -> Result<AlkaneId> {
let d = self.epoch_contract_pointer(index).get();
if d.is_empty() { return Err(anyhow!("epoch {} not found", index)); }
Ok(AlkaneId::try_from(d.as_slice().to_vec())?)
}
fn has_epoch_for_absolute(&self, abs_epoch: u128) -> bool {
self.epoch_absolute_pointer(abs_epoch).get_value::<u128>() == 1
}
// ── Handlers ──────────────────────────────────────────────────
fn initialize(
&self,
lp_token: AlkaneId,
fire_token: AlkaneId,
staking_template: u128,
position_template: u128,
wlp_template: u128,
activation_block: u128,
beacon_id: AlkaneId,
position_beacon: AlkaneId,
) -> Result<CallResponse> {
if self.auth_token_pointer().get().len() > 0 {
self.only_owner()?;
}
self.observe_initialization()?;
self.lp_token_pointer().set(Arc::new(lp_token.into()));
self.fire_token_pointer().set(Arc::new(fire_token.into()));
self.staking_template_pointer().set_value(staking_template);
self.position_template_pointer().set_value(position_template);
self.wlp_template_pointer().set_value(wlp_template);
self.epoch_duration_pointer().set_value(HALVING_INTERVAL as u128);
self.epoch_count_pointer().set_value(0u128);
// Store activation block (0 = use ACTIVATION_BLOCK constant)
if activation_block > 0 {
self.activation_block_pointer().set_value(activation_block);
}
// Store staking beacon ID (if {0,0}, beacon pattern disabled — backward compat)
if beacon_id.block != 0 || beacon_id.tx != 0 {
self.beacon_id_pointer().set(Arc::new(beacon_id.into()));
}
// Store position-token beacon ID (if {0,0}, position-token clones use
// direct template — upgrade not propagated to existing NFTs).
if position_beacon.block != 0 || position_beacon.tx != 0 {
self.position_beacon_pointer().set(Arc::new(position_beacon.into()));
}
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn create_next_epoch(&self) -> Result<CallResponse> {
let ctx = self.context()?;
let dur = self.epoch_duration();
let h = self.height() as u128;
let activation = self.activation();
// Sequential epoch index
let count = self.epoch_count();
// Compute target absolute epoch from global grid (height / HALVING_INTERVAL).
// First epoch (count=0) starts at activation block, ends at next halving boundary.
let target_abs_epoch = if count == 0 {
activation / dur // epoch containing ACTIVATION_BLOCK
} else {
self.epoch_abs_id_pointer(count - 1).get_value::<u128>() + 1
};
// Limit: can only create current period or one ahead (pre-create)
let current_abs = h / dur;
if target_abs_epoch > current_abs + 1 {
return Err(anyhow!("cannot create epoch {} — max is {} (current + 1)", target_abs_epoch, current_abs + 1));
}
if self.has_epoch_for_absolute(target_abs_epoch) {
return Err(anyhow!("epoch already exists for period {}", target_abs_epoch));
}
let lp = self.lp_token()?;
let fire = self.fire_token()?;
let staking_tmpl = self.staking_template();
let pos_tmpl = self.position_template();
let wlp_tmpl = self.wlp_template();
// First epoch starts at ACTIVATION_BLOCK (shortened epoch).
// Subsequent epochs start at their grid boundary.
let start_block = if count == 0 { activation } else { target_abs_epoch * dur };
let expiry = (target_abs_epoch + 1) * dur - 1;
// Step 1: Clone template via block 6 (safe opcode, no init)
// Use opcode 36863 (forward) for beacon-proxy templates — GetName (99) would
// hit fallback → delegatecall before beacon is initialized → revert.
// For direct staking templates, 99 (GetName) works fine.
let clone_opcode: u128 = if self.has_beacon() { 36863 } else { 99 };
let clone_seq = self.sequence();
self.call(
&Cellpack {
target: AlkaneId { block: 6, tx: staking_tmpl },
inputs: vec![clone_opcode],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
let epoch_contract = AlkaneId { block: 2, tx: clone_seq };
// Step 1.5: If beacon enabled, initialize beacon proxy first.
// The clone is a beacon-proxy template, needs to know which beacon to query.
// Beacon proxy init = opcode 32767, uses /proxy_initialized (separate from /initialized).
if self.has_beacon() {
let beacon = self.beacon_id();
self.call(
&Cellpack {
target: epoch_contract.clone(),
inputs: vec![32767, beacon.block, beacon.tx], // BeaconProxy.initialize(beacon)
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
}
// Step 2: Initialize staking logic (direct or via delegatecall through beacon proxy).
// Pass sequential epoch count as halving_epoch so emission rate halves correctly.
// count=0 → epoch 0 → full rate, count=1 → epoch 1 → half rate, etc.
// Also pass position_beacon so each clone knows where to wire position-NFT
// proxies. {0,0} = direct template clone (legacy / tests).
let pos_beacon = self.position_beacon();
self.call(
&Cellpack {
target: epoch_contract.clone(),
inputs: vec![
0, // Initialize opcode
lp.block, lp.tx,
fire.block, fire.tx,
pos_tmpl,
wlp_tmpl,
start_block,
expiry,
count, // halving_epoch = sequential epoch number
pos_beacon.block, pos_beacon.tx,
],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
// Step 3: Register the epoch contract as authorized staker with fire-token
self.call(
&Cellpack {
target: fire.clone(),
inputs: vec![
79, // RegisterStaker opcode
epoch_contract.block,
epoch_contract.tx,
],
},
&AlkaneTransferParcel::default(),
self.fuel(),
)?;
// Register epoch
let index = self.epoch_count();
self.epoch_contract_pointer(index)
.set(Arc::new(epoch_contract.clone().into()));
self.epoch_absolute_pointer(target_abs_epoch).set_value(1u128);
self.epoch_abs_id_pointer(index).set_value(target_abs_epoch);
self.epoch_count_pointer().set_value(index + 1);
// Return epoch contract info
let mut response = CallResponse::forward(&ctx.incoming_alkanes);
response.data.extend_from_slice(&epoch_contract.block.to_le_bytes());
response.data.extend_from_slice(&epoch_contract.tx.to_le_bytes());
Ok(response)
}
// ── Views ─────────────────────────────────────────────────────
fn get_epoch_count(&self) -> Result<CallResponse> {
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data = self.epoch_count().to_le_bytes().to_vec();
Ok(r)
}
fn get_epoch_contract(&self, epoch_index: u128) -> Result<CallResponse> {
let id = self.get_epoch_contract_id(epoch_index)?;
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data.extend_from_slice(&id.block.to_le_bytes());
r.data.extend_from_slice(&id.tx.to_le_bytes());
Ok(r)
}
fn get_current_epoch_index(&self) -> Result<CallResponse> {
let count = self.epoch_count();
let h = self.height() as u128;
let dur = self.epoch_duration();
// Use stored activation — respects devnet override; falls back to constant.
let activation = self.activation();
// Find the active (non-expired) epoch: latest one whose start_block <= height
// AND whose expiry >= height. If all epochs are expired, return last one
// (stale data is better than revert for view function — oracle uses MIN_REFERENCE_LP fallback).
let mut current = 0u128;
for i in (0..count).rev() {
let abs_epoch = self.epoch_abs_id_pointer(i).get_value::<u128>();
// Epoch 0 start = activation (mirrors create_next_epoch). Later epochs
// start on the halving grid.
let start_block = if i == 0 { activation } else { abs_epoch * dur };
let expiry = (abs_epoch + 1) * dur - 1;
if h >= start_block && h <= expiry {
current = i;
break;
}
if h >= start_block {
current = i; // fallback to latest started (even if expired)
break;
}
}
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data = current.to_le_bytes().to_vec();
Ok(r)
}
fn get_lp_token(&self) -> Result<CallResponse> {
let id = self.lp_token()?;
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data.extend_from_slice(&id.block.to_le_bytes());
r.data.extend_from_slice(&id.tx.to_le_bytes());
Ok(r)
}
fn get_fire_token(&self) -> Result<CallResponse> {
let id = self.fire_token()?;
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data.extend_from_slice(&id.block.to_le_bytes());
r.data.extend_from_slice(&id.tx.to_le_bytes());
Ok(r)
}
fn get_name(&self) -> Result<CallResponse> {
let ctx = self.context()?;
let mut r = CallResponse::forward(&ctx.incoming_alkanes);
r.data = b"FIRE Staking Factory".to_vec();
Ok(r)
}
}
declare_alkane! {
impl AlkaneResponder for FireStakingFactory {
type Message = FireStakingFactoryMessage;
}
}

Verified Source