Verified Source

2:89243✓ Verified

Commitbf647d03491e

Match94.1%

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-master-auth/src/lib.rs3,128 B

//! fire-master-auth
//!
//! A single fungible auth token shared by every FIRE upgradeable proxy/beacon.
//! Deployed at a fixed FIRE slot (4:255) so all proxies can reference it at deploy time.
//!
//! Init mints `units` units to the deployer. Opcode 1 (`authenticate`) implements
//! the contract that `only_owner()` in `alkanes-runtime::auth` calls — returns
//! `0x01` if `incoming_alkanes` contains 1+ unit of self.
use alkanes_runtime::{
declare_alkane,
message::MessageDispatch,
runtime::AlkaneResponder,
};
#[allow(unused_imports)]
use alkanes_runtime::{
println,
stdio::{stdout, Write},
};
use alkanes_support::{parcel::AlkaneTransfer, response::CallResponse};
use anyhow::{anyhow, Result};
use metashrew_support::compat::to_arraybuffer_layout;
#[derive(Default)]
pub struct FireMasterAuth(());
impl AlkaneResponder for FireMasterAuth {}
#[derive(MessageDispatch)]
enum FireMasterAuthMessage {
/// Mint `units` of self to the caller. One-shot.
#[opcode(0)]
Initialize { units: u128 },
/// Verify caller holds 1+ unit of self. Matches the contract called by
/// `only_owner()` in alkanes-runtime/auth.rs.
#[opcode(1)]
Authenticate,
/// Token name — "FIRE-AUTH".
#[opcode(99)]
#[returns(String)]
GetName,
/// Token symbol — "FIRE-AUTH" (matches name; this is an auth NFT, not a swap token).
#[opcode(100)]
#[returns(String)]
GetSymbol,
}
impl FireMasterAuth {
fn initialize(&self, units: u128) -> Result<CallResponse> {
self.observe_initialization()?;
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.alkanes.0.push(AlkaneTransfer {
id: context.myself,
value: units,
});
Ok(response)
}
fn authenticate(&self) -> Result<CallResponse> {
let context = self.context()?;
if context.incoming_alkanes.0.len() != 1 {
return Err(anyhow!("authenticate: expect exactly one incoming alkane"));
}
let t = &context.incoming_alkanes.0[0];
if t.id != context.myself {
return Err(anyhow!("authenticate: incoming alkane is not the FIRE master auth"));
}
if t.value < 1 {
return Err(anyhow!("authenticate: less than 1 unit of FIRE master auth supplied"));
}
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = vec![0x01];
Ok(response)
}
fn get_name(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = b"FIRE-AUTH".to_vec();
Ok(response)
}
fn get_symbol(&self) -> Result<CallResponse> {
let context = self.context()?;
let mut response = CallResponse::forward(&context.incoming_alkanes);
response.data = b"FIRE-AUTH".to_vec();
Ok(response)
}
}
declare_alkane! {
impl AlkaneResponder for FireMasterAuth {
type Message = FireMasterAuthMessage;
}
}