Verified Source

2:77632✓ Verified

Commitbf647d03491e

Match93.9%

Files53

The exact source a sandboxed build reproduced the on-chain wasm from – served from SUBFROST's verified-build database, since the origin repository is private.

Build & verification details

Reproduction recipestructural match

Every fixture below was reversed from the on-chain bytecode, then pinned in a sandboxed rebuild. Reproduced deterministically – the source genuinely compiles to this bytecode.

Toolchain

Build environment

HOME

/Users/misha

← embedded registry/git-checkout paths

CARGO_HOME

/Users/misha/.cargo

env

PROTOC=/usr/bin/protoc

env

CC_wasm32_unknown_unknown=Homebrew clang 20.1.7 (recipe origin 20.1.4)

env

AR_wasm32_unknown_unknown=llvm-ar

env

build dir = /Users/misha/fire

Git dependency

repo

kungfuflex/alkanes-rs

rev

550aea1a38c8b5299b8adc6df49d2e27569613eb

← fingerprint git_deps

source-id

bare (matches -C metadata → mono ordering)

alkanes/fire-series-token/src/lib.rs7,520 B

//! FIRE Series Token — Fungible PT (wLP) token template
//!
//! Cloned via block 6 factory pattern by fire-staking, one per epoch.
//! Represents the principal claim on LP — redeemable 1:1 after epoch expiry.
//!
//! Only the vault (fire-staking, stored as context.caller during init)
//! can mint and burn.
use alkanes_runtime::{
declare_alkane, message::MessageDispatch, runtime::AlkaneResponder, token::Token,
};
use alkanes_support::{id::AlkaneId, parcel::AlkaneTransfer, response::CallResponse};
use anyhow::{anyhow, Result};
use metashrew_support::compat::to_arraybuffer_layout;
#[derive(Default)]
pub struct FireSeriesToken(());
impl Token for FireSeriesToken {
fn name(&self) -> String {
let series = self.get_u128(self.k_series_id());
format!("FIRE-PT-{}", series)
}
fn symbol(&self) -> String {
let series = self.get_u128(self.k_series_id());
format!("FIRE-PT-{}", series)
}
}
impl AlkaneResponder for FireSeriesToken {}
#[derive(MessageDispatch)]
pub enum FireSeriesTokenMessage {
/// Initialize: called once by vault (fire-staking) during factory clone.
/// vault = context.caller; series_id = epoch index → produces "FIRE-PT-{series_id}".
#[opcode(0)]
Initialize {
vault_block: u128,
vault_tx: u128,
series_id: u128,
},
/// Mint tokens — only vault can call.
/// Minted tokens are returned in CallResponse to be forwarded to user.
#[opcode(10)]
Mint { amount: u128 },
/// Burn tokens — only vault can call.
/// Vault must send the tokens as incomingAlkanes before calling burn.
#[opcode(11)]
Burn { amount: u128 },
/// Forward any incoming alkanes back to caller (utility opcode).
#[opcode(50)]
ForwardIncoming,
// ── View functions ────────────────────────────────────────────
/// Get total supply
#[opcode(41)]
#[returns(u128)]
GetTotalSupply,
/// Get series ID
#[opcode(43)]
#[returns(u128)]
GetSeriesId,
/// Get vault (fire-staking) AlkaneId — 32 bytes LE
#[opcode(44)]
#[returns(Vec<u8>)]
GetVault,
/// Get token name
#[opcode(99)]
#[returns(String)]
GetName,
/// Get token symbol
#[opcode(100)]
#[returns(String)]
GetSymbol,
}
impl FireSeriesToken {
// ── Storage keys ──────────────────────────────────────────────
fn k_vault(&self) -> Vec<u8> { b"/vault".to_vec() }
fn k_series_id(&self) -> Vec<u8> { b"/series_id".to_vec() }
fn k_total(&self) -> Vec<u8> { b"/total".to_vec() }
// ── Storage helpers ───────────────────────────────────────────
fn put_alkane_id(&self, key: Vec<u8>, id: &AlkaneId) {
let mut v = Vec::with_capacity(32);
v.extend_from_slice(&id.block.to_le_bytes());
v.extend_from_slice(&id.tx.to_le_bytes());
self.store(key, v);
}
fn get_alkane_id(&self, key: Vec<u8>) -> AlkaneId {
let raw = self.load(key);
if raw.len() < 32 {
return AlkaneId { block: 0, tx: 0 };
}
let mut b = [0u8; 16];
b.copy_from_slice(&raw[0..16]);
let mut t = [0u8; 16];
t.copy_from_slice(&raw[16..32]);
AlkaneId {
block: u128::from_le_bytes(b),
tx: u128::from_le_bytes(t),
}
}
fn get_u128(&self, k: Vec<u8>) -> u128 {
let r = self.load(k);
if r.len() < 16 {
0
} else {
let mut b = [0u8; 16];
b.copy_from_slice(&r[..16]);
u128::from_le_bytes(b)
}
}
fn put_u128(&self, k: Vec<u8>, v: u128) {
self.store(k, v.to_le_bytes().to_vec());
}
// ── Auth ──────────────────────────────────────────────────────
fn vault_id(&self) -> AlkaneId {
self.get_alkane_id(self.k_vault())
}
fn only_vault(&self) -> Result<()> {
let ctx = self.context()?;
let vault = self.vault_id();
if ctx.caller != vault {
return Err(anyhow!("only vault"));
}
Ok(())
}
// ── Handlers ──────────────────────────────────────────────────
fn initialize(
&self,
vault_block: u128,
vault_tx: u128,
series_id: u128,
) -> Result<CallResponse> {
self.observe_initialization()?;
self.put_alkane_id(self.k_vault(), &AlkaneId { block: vault_block, tx: vault_tx });
self.put_u128(self.k_series_id(), series_id);
self.put_u128(self.k_total(), 0);
Ok(CallResponse::default())
}
fn mint(&self, amount: u128) -> Result<CallResponse> {
self.only_vault()?;
if amount == 0 {
return Err(anyhow!("amount=0"));
}
let total = self.get_u128(self.k_total());
self.put_u128(
self.k_total(),
total.checked_add(amount).ok_or_else(|| anyhow!("total overflow"))?,
);
let ctx = self.context()?;
let mut resp = CallResponse::default();
resp.alkanes.0.push(AlkaneTransfer {
id: ctx.myself,
value: amount,
});
Ok(resp)
}
fn burn(&self, amount: u128) -> Result<CallResponse> {
self.only_vault()?;
if amount == 0 {
return Err(anyhow!("amount=0"));
}
let total = self.get_u128(self.k_total());
self.put_u128(
self.k_total(),
total.checked_sub(amount).ok_or_else(|| anyhow!("total underflow"))?,
);
Ok(CallResponse::default())
}
fn forward_incoming(&self) -> Result<CallResponse> {
let ctx = self.context()?;
Ok(CallResponse::forward(&ctx.incoming_alkanes))
}
// ── Views ─────────────────────────────────────────────────────
fn get_total_supply(&self) -> Result<CallResponse> {
let mut resp = CallResponse::default();
resp.data = self.get_u128(self.k_total()).to_le_bytes().to_vec();
Ok(resp)
}
fn get_series_id(&self) -> Result<CallResponse> {
let mut resp = CallResponse::default();
resp.data = self.get_u128(self.k_series_id()).to_le_bytes().to_vec();
Ok(resp)
}
fn get_vault(&self) -> Result<CallResponse> {
let vault = self.vault_id();
let mut resp = CallResponse::default();
resp.data.extend_from_slice(&vault.block.to_le_bytes());
resp.data.extend_from_slice(&vault.tx.to_le_bytes());
Ok(resp)
}
fn get_name(&self) -> Result<CallResponse> {
let mut resp = CallResponse::default();
resp.data = self.name().into_bytes();
Ok(resp)
}
fn get_symbol(&self) -> Result<CallResponse> {
let mut resp = CallResponse::default();
resp.data = self.symbol().into_bytes();
Ok(resp)
}
}
declare_alkane! {
impl AlkaneResponder for FireSeriesToken {
type Message = FireSeriesTokenMessage;
}
}