Verified Source

2:85482✓ 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-upgradeable/src/lib.rs3,025 B

//! fire-upgradeable
//!
//! Identical to `alkanes-std-upgradeable` except `initialize` accepts an
//! **existing** auth-token AlkaneId instead of minting a fresh per-proxy token.
//! All FIRE proxies point at one master auth → single key controls all upgrades.
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, response::CallResponse};
use anyhow::Result;
use metashrew_support::compat::to_arraybuffer_layout;
use metashrew_support::index_pointer::KeyValuePointer;
use std::sync::Arc;
#[derive(Default)]
pub struct FireUpgradeable(());
impl FireUpgradeable {
pub fn alkane_pointer() -> StoragePointer {
StoragePointer::from_keyword("/implementation")
}
pub fn alkane() -> Result<AlkaneId> {
Ok(Self::alkane_pointer().get().as_ref().clone().try_into()?)
}
pub fn set_alkane(v: AlkaneId) {
Self::alkane_pointer().set(Arc::new(<AlkaneId as Into<Vec<u8>>>::into(v)));
}
}
impl AuthenticatedResponder for FireUpgradeable {}
impl AlkaneResponder for FireUpgradeable {
fn fallback(&self) -> Result<CallResponse> {
let context = self.context()?;
let cellpack = Cellpack {
target: Self::alkane()?,
inputs: context.inputs.clone(),
};
self.delegatecall(&cellpack, &context.incoming_alkanes, self.fuel())
}
}
#[derive(MessageDispatch)]
enum FireUpgradeableMessage {
/// Initialize the proxy with an existing master auth token.
/// shared_auth must point at an existing alkanes-std-auth-token instance.
#[opcode(32767)]
Initialize {
implementation: AlkaneId,
shared_auth: AlkaneId,
},
/// Upgrade the implementation. Requires master auth token in incoming_alkanes.
#[opcode(32766)]
Upgrade { implementation: AlkaneId },
/// Passthrough for incoming alkanes (no-op).
#[opcode(36863)]
Forward,
}
impl FireUpgradeable {
fn initialize(&self, implementation: AlkaneId, shared_auth: AlkaneId) -> Result<CallResponse> {
self.observe_proxy_initialization()?;
let context = self.context()?;
Self::set_alkane(implementation);
self.set_auth_token(shared_auth)?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn upgrade(&self, implementation: AlkaneId) -> Result<CallResponse> {
let context = self.context()?;
self.only_owner()?;
Self::set_alkane(implementation);
Ok(CallResponse::forward(&context.incoming_alkanes))
}
fn forward(&self) -> Result<CallResponse> {
let context = self.context()?;
Ok(CallResponse::forward(&context.incoming_alkanes))
}
}
declare_alkane! {
impl AlkaneResponder for FireUpgradeable {
type Message = FireUpgradeableMessage;
}
}