Source – Alkane 2:95892 — SUBFROST Explorer

alkanes/fire-token/src/lib.rs11,035 B

//! FIRE Token Contract
//!
//! The FIRE token with a capped supply of 2.1M tokens.
//! 0% premine — 100% emission:
//! - 85% staking emission pool (1,785,000 FIRE)
//! - 15% bonding emission pool (315,000 FIRE)
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_std_factory_support::MintableToken;
use alkanes_support::{id::AlkaneId, parcel::AlkaneTransfer, response::CallResponse};
use anyhow::{anyhow, Result};
use fire_support::{MAX_SUPPLY, STAKING_EMISSION_POOL, BONDING_EMISSION_POOL};
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
#[derive(Default)]
pub struct FireToken(());
impl MintableToken for FireToken {}
impl AlkaneResponder for FireToken {}
impl AuthenticatedResponder for FireToken {}
#[derive(MessageDispatch)]
enum FireTokenMessage {
/// Initialize the FIRE token (no premine — just set authorized minters)
#[opcode(0)]
Initialize {
staking_contract: AlkaneId,
bonding_contract: AlkaneId,
},
/// Mint from staking emission pool (only staking contract)
#[opcode(77)]
MintFromStakingPool { amount: u128 },
/// Mint from bonding emission pool (only bonding contract)
#[opcode(78)]
MintFromBondingPool { amount: u128 },
/// Register a new authorized staker (only staking authority can call)
#[opcode(79)]
RegisterStaker { staker: AlkaneId },
/// Burn FIRE tokens
#[opcode(88)]
Burn,
/// Get token name
#[opcode(99)]
#[returns(String)]
GetName,
/// Get token symbol
#[opcode(100)]
#[returns(String)]
GetSymbol,
/// Get current total supply
#[opcode(101)]
#[returns(u128)]
GetTotalSupply,
/// Get maximum supply (2.1M)
#[opcode(102)]
#[returns(u128)]
GetMaxSupply,
/// Get remaining staking emission pool
#[opcode(103)]
#[returns(u128)]
GetStakingPoolRemaining,
/// Get remaining bonding emission pool
#[opcode(104)]
#[returns(u128)]
GetBondingPoolRemaining,
}
impl FireToken {
// ── Storage ────────────────────────────────────────────────────
fn staking_contract_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/staking_contract")
}
fn bonding_contract_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/bonding_contract")
}
fn staking_pool_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/staking_pool_remaining")
}
fn bonding_pool_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/bonding_pool_remaining")
}
fn staker_authorized_pointer(&self, id: &AlkaneId) -> StoragePointer {
StoragePointer::from_keyword("/staker_auth/")
.select(&<AlkaneId as Into<Vec<u8>>>::into(id.clone()))
}
// ── Getters ───────────────────────────────────────────────────
fn staking_contract(&self) -> Result<AlkaneId> {
let data = self.staking_contract_pointer().get();
if data.is_empty() {
return Err(anyhow!("staking contract 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 staking_pool_remaining(&self) -> u128 {
self.staking_pool_pointer().get_value::<u128>()
}
fn bonding_pool_remaining(&self) -> u128 {
self.bonding_pool_pointer().get_value::<u128>()
}
// ── Auth ──────────────────────────────────────────────────────
fn only_staking(&self) -> Result<()> {
let context = self.context()?;
if self.staker_authorized_pointer(&context.caller).get_value::<u128>() != 1 {
return Err(anyhow!("only authorized staking contract can mint from staking pool"));
}
Ok(())
}
fn only_staking_authority(&self) -> Result<()> {
let context = self.context()?;
let authority = self.staking_contract()?;
if context.caller != authority {
return Err(anyhow!("only staking authority can register stakers"));
}
Ok(())
}
fn only_bonding(&self) -> Result<()> {
let context = self.context()?;
let bonding = self.bonding_contract()?;
if context.caller != bonding {
return Err(anyhow!("only bonding contract can mint from bonding pool"));
}
Ok(())
}
// ── Helpers ───────────────────────────────────────────────────
fn mint_from_pool(
&self,
pool_pointer: &mut StoragePointer,
amount: u128,
) -> Result<CallResponse> {
// Check pool has enough
let remaining = pool_pointer.get_value::<u128>();
if amount > remaining {
return Err(anyhow!(
"insufficient emission pool: requested {}, available {}",
amount,
remaining
));
}
// Check total supply won't exceed max
let current_supply = self.total_supply();
if current_supply.checked_add(amount).ok_or_else(|| anyhow!("overflow"))? > MAX_SUPPLY {
return Err(anyhow!("would exceed max supply"));
}
// Decrease pool
pool_pointer.set_value(remaining - amount);
// Mint
let context = self.context()?;
let transfer = <Self as MintableToken>::mint(self, &context, amount)?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.alkanes.0.push(transfer);
Ok(response)
}
// ── Handlers ──────────────────────────────────────────────────
fn initialize(
&self,
staking_contract: AlkaneId,
bonding_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()?;
// Set token metadata
<Self as MintableToken>::set_name_and_symbol_str(
self,
String::from("FIRE"),
String::from("FIRE"),
);
// Store authorized minters
self.staking_contract_pointer()
.set(Arc::new(staking_contract.clone().into()));
self.bonding_contract_pointer()
.set(Arc::new(bonding_contract.into()));
// Mark staking_contract as authorized staker (works for both direct and factory deploy)
self.staker_authorized_pointer(&staking_contract).set_value(1u128);
// Set emission pools (no premine — nothing minted here)
self.staking_pool_pointer().set_value(STAKING_EMISSION_POOL);
self.bonding_pool_pointer().set_value(BONDING_EMISSION_POOL);
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn register_staker(&self, staker: AlkaneId) -> Result<CallResponse> {
self.only_staking_authority()?;
self.staker_authorized_pointer(&staker).set_value(1u128);
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn mint_from_staking_pool(&self, amount: u128) -> Result<CallResponse> {
self.only_staking()?;
self.mint_from_pool(&mut self.staking_pool_pointer(), amount)
}
fn mint_from_bonding_pool(&self, amount: u128) -> Result<CallResponse> {
self.only_bonding()?;
self.mint_from_pool(&mut self.bonding_pool_pointer(), amount)
}
fn burn(&self) -> Result<CallResponse> {
let context = self.context()?;
let fire_transfer = context
.incoming_alkanes
.0
.iter()
.find(|t| t.id == context.myself)
.ok_or_else(|| anyhow!("no FIRE tokens to burn"))?;
if fire_transfer.value == 0 {
return Err(anyhow!("cannot burn zero tokens"));
}
self.decrease_total_supply(fire_transfer.value)?;
let mut response = CallResponse::default();
for transfer in &context.incoming_alkanes.0 {
if transfer.id != context.myself {
response.alkanes.0.push(transfer.clone());
}
}
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.name().into_bytes();
Ok(response)
}
fn get_symbol(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.symbol().into_bytes();
Ok(response)
}
fn get_total_supply(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.total_supply().to_le_bytes().to_vec();
Ok(response)
}
fn get_max_supply(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = MAX_SUPPLY.to_le_bytes().to_vec();
Ok(response)
}
fn get_staking_pool_remaining(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.staking_pool_remaining().to_le_bytes().to_vec();
Ok(response)
}
fn get_bonding_pool_remaining(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.bonding_pool_remaining().to_le_bytes().to_vec();
Ok(response)
}
}
declare_alkane! {
impl AlkaneResponder for FireToken {
type Message = FireTokenMessage;
}
}

Verified Source