Source – Alkane 2:88360 — SUBFROST Explorer

alkanes/fire-position-token/src/lib.rs13,582 B

//! FIRE Position Token — NFT receipt for staking positions
//!
//! Each instance represents a single staking position. Created by the staking
//! contract via factory cellpack on `stake()`, consumed on `unstake()`.
//! User holds 1 unit in their wallet as proof of ownership.
//!
//! Architecture: position-token pattern from boiler/hude/review, adapted to
//! use MessageDispatch + declare_alkane! matching the fire repo conventions.
//!
//! SECURITY:
//! - observe_initialization() prevents double-init
//! - set_reward_debt() only callable by vault (context.caller == vault_id)
//! - All other fields are write-once (set in initialize, never changed)
//! - Supply is exactly 1 unit per instance (minted in initialize)
use alkanes_runtime::{
declare_alkane, message::MessageDispatch, runtime::AlkaneResponder, storage::StoragePointer,
};
#[allow(unused_imports)]
use alkanes_runtime::{
println,
stdio::{stdout, Write},
};
use alkanes_support::{
id::AlkaneId,
parcel::AlkaneTransfer,
response::CallResponse,
};
use anyhow::{anyhow, Result};
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
#[derive(Default)]
pub struct FirePositionToken(());
impl AlkaneResponder for FirePositionToken {}
#[derive(MessageDispatch)]
enum FirePositionTokenMessage {
/// Initialize position with all metadata. Mints 1 unit of self.
/// epoch_id appears in the name/symbol so positions across epochs are distinguishable.
#[opcode(0)]
Initialize {
position_id: u128,
deposit_amount: u128,
weighted_amount: u128,
lock_end: u128,
lock_duration: u128,
multiplier: u128,
reward_checkpoint: u128,
deposit_token: AlkaneId,
epoch_id: u128,
},
/// Update reward checkpoint — ONLY callable by the vault that created this.
/// Prevents double-claim exploit on claim_rewards().
#[opcode(1)]
SetRewardCheckpoint { new_checkpoint: u128 },
// ── View functions ─────────────────────────────────────────────
#[opcode(10)]
#[returns(u128)]
GetPositionId,
#[opcode(11)]
#[returns(u128)]
GetDepositAmount,
#[opcode(12)]
#[returns(u128)]
GetWeightedAmount,
#[opcode(13)]
#[returns(u128)]
GetLockEnd,
#[opcode(14)]
#[returns(u128)]
GetLockDuration,
#[opcode(15)]
#[returns(u128)]
GetMultiplier,
#[opcode(16)]
#[returns(u128)]
GetRewardCheckpoint,
/// Get the AlkaneId of the token deposited into this position
#[opcode(19)]
#[returns(Vec<u8>)]
GetDepositToken,
/// Returns all fields packed: 7 × u128 LE + AlkaneId (2 × u128) = 144 bytes
/// [position_id, deposit_amount, weighted_amount, lock_end,
/// lock_duration, multiplier, reward_checkpoint, deposit_token_block, deposit_token_tx]
#[opcode(23)]
#[returns(Vec<u8>)]
GetAllDetails,
#[opcode(99)]
#[returns(String)]
GetName,
#[opcode(100)]
#[returns(String)]
GetSymbol,
}
impl FirePositionToken {
// ── Storage ────────────────────────────────────────────────────
fn vault_id_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/vault_id")
}
fn position_id_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/position_id")
}
fn deposit_amount_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/deposit_amount")
}
fn weighted_amount_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/weighted_amount")
}
fn lock_end_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/lock_end")
}
fn lock_duration_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/lock_duration")
}
fn multiplier_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/multiplier")
}
fn reward_checkpoint_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/reward_checkpoint")
}
fn deposit_token_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/deposit_token")
}
fn name_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/name")
}
fn symbol_pointer(&self) -> StoragePointer {
StoragePointer::from_keyword("/symbol")
}
// ── Getters ────────────────────────────────────────────────────
fn vault_id(&self) -> AlkaneId {
let data = self.vault_id_pointer().get();
if data.is_empty() {
return AlkaneId::default();
}
AlkaneId::try_from(data.as_slice().to_vec()).unwrap_or_default()
}
fn position_id(&self) -> u128 {
self.position_id_pointer().get_value::<u128>()
}
fn deposit_amount(&self) -> u128 {
self.deposit_amount_pointer().get_value::<u128>()
}
fn weighted_amount(&self) -> u128 {
self.weighted_amount_pointer().get_value::<u128>()
}
fn lock_end(&self) -> u128 {
self.lock_end_pointer().get_value::<u128>()
}
fn lock_duration_val(&self) -> u128 {
self.lock_duration_pointer().get_value::<u128>()
}
fn multiplier(&self) -> u128 {
self.multiplier_pointer().get_value::<u128>()
}
fn reward_checkpoint(&self) -> u128 {
self.reward_checkpoint_pointer().get_value::<u128>()
}
fn deposit_token(&self) -> AlkaneId {
let data = self.deposit_token_pointer().get();
if data.is_empty() {
return AlkaneId::default();
}
AlkaneId::try_from(data.as_slice().to_vec()).unwrap_or_default()
}
// ── Auth ───────────────────────────────────────────────────────
fn only_vault(&self) -> Result<()> {
let context = self.context()?;
let vault = self.vault_id();
if context.caller != vault {
return Err(anyhow!(
"only vault can call this (caller={:?}, vault={:?})",
context.caller,
vault
));
}
Ok(())
}
// ── Handlers ───────────────────────────────────────────────────
fn initialize(
&self,
position_id: u128,
deposit_amount: u128,
weighted_amount: u128,
lock_end: u128,
lock_duration: u128,
multiplier: u128,
reward_checkpoint: u128,
deposit_token: AlkaneId,
epoch_id: u128,
) -> Result<CallResponse> {
let context = self.context()?;
self.observe_initialization()?;
// Store vault identity (context.caller = staking factory during factory create)
self.vault_id_pointer()
.set(Arc::new(context.caller.clone().into()));
// Store position data
self.position_id_pointer().set_value(position_id);
self.deposit_amount_pointer().set_value(deposit_amount);
self.weighted_amount_pointer().set_value(weighted_amount);
self.lock_end_pointer().set_value(lock_end);
self.lock_duration_pointer().set_value(lock_duration);
self.multiplier_pointer().set_value(multiplier);
self.reward_checkpoint_pointer().set_value(reward_checkpoint);
self.deposit_token_pointer()
.set(Arc::new(deposit_token.into()));
// Name and symbol include epoch so positions across epochs are distinguishable.
// Example: epoch 0 first stake → "FIRE-POS-0-0", epoch 1 first stake → "FIRE-POS-1-0".
let name_str = format!("FIRE-POS-{}-{}", epoch_id, position_id);
let symbol_str = name_str.clone();
self.name_pointer()
.set(Arc::new(name_str.into_bytes()));
self.symbol_pointer()
.set(Arc::new(symbol_str.into_bytes()));
// Mint exactly 1 unit of self → returned to factory → returned to user
let mut response = CallResponse::default();
response.alkanes.0.push(AlkaneTransfer {
id: context.myself.clone(),
value: 1u128,
});
Ok(response)
}
fn set_reward_checkpoint(&self, new_checkpoint: u128) -> Result<CallResponse> {
self.only_vault()?;
self.reward_checkpoint_pointer().set_value(new_checkpoint);
Ok(CallResponse::default())
}
// ── Views ──────────────────────────────────────────────────────
fn get_position_id(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.position_id().to_le_bytes().to_vec();
Ok(response)
}
fn get_deposit_amount(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.deposit_amount().to_le_bytes().to_vec();
Ok(response)
}
fn get_weighted_amount(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.weighted_amount().to_le_bytes().to_vec();
Ok(response)
}
fn get_lock_end(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.lock_end().to_le_bytes().to_vec();
Ok(response)
}
fn get_lock_duration(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.lock_duration_val().to_le_bytes().to_vec();
Ok(response)
}
fn get_multiplier(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.multiplier().to_le_bytes().to_vec();
Ok(response)
}
fn get_reward_checkpoint(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = self.reward_checkpoint().to_le_bytes().to_vec();
Ok(response)
}
fn get_deposit_token(&self) -> Result<CallResponse> {
let context = self.context()?;
let dt = self.deposit_token();
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data.extend_from_slice(&dt.block.to_le_bytes());
response.data.extend_from_slice(&dt.tx.to_le_bytes());
Ok(response)
}
fn get_all_details(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
let dt = self.deposit_token();
// 9 × u128 LE = 144 bytes
response.data.extend_from_slice(&self.position_id().to_le_bytes());
response.data.extend_from_slice(&self.deposit_amount().to_le_bytes());
response.data.extend_from_slice(&self.weighted_amount().to_le_bytes());
response.data.extend_from_slice(&self.lock_end().to_le_bytes());
response.data.extend_from_slice(&self.lock_duration_val().to_le_bytes());
response.data.extend_from_slice(&self.multiplier().to_le_bytes());
response.data.extend_from_slice(&self.reward_checkpoint().to_le_bytes());
response.data.extend_from_slice(&dt.block.to_le_bytes());
response.data.extend_from_slice(&dt.tx.to_le_bytes());
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let context = self.context()?;
let data = self.name_pointer().get();
// Fallback for un-initialized template — should never trigger in practice
// because every position is initialized via the factory clone path.
let fallback = format!("FIRE-POS-?-{}", self.position_id());
let name = if data.is_empty() {
fallback.clone()
} else {
String::from_utf8(data.as_ref().clone()).unwrap_or(fallback)
};
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = name.into_bytes();
Ok(response)
}
fn get_symbol(&self) -> Result<CallResponse> {
let context = self.context()?;
let data = self.symbol_pointer().get();
let fallback = format!("FIRE-POS-?-{}", self.position_id());
let symbol = if data.is_empty() {
fallback.clone()
} else {
String::from_utf8(data.as_ref().clone()).unwrap_or(fallback)
};
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = symbol.into_bytes();
Ok(response)
}
}
declare_alkane! {
impl AlkaneResponder for FirePositionToken {
type Message = FirePositionTokenMessage;
}
}

Verified Source