Verified Source

2:314✓ Reproducible

Repositorykungfuflex/free-mint (private)

Commite33d5e8

Match100.0%

Files14

The exact source a sandboxed build reproduced the on-chain wasm from (bit-for-bit) – 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

/home/lee

← embedded registry/git-checkout paths

CARGO_HOME

/home/lee/.cargo

env

CC_wasm32_unknown_unknown=clang-14

Git dependency

repo

kungfuflex/alkanes-rs

rev

d787cdd

← fingerprint git_deps

source-id

bare (matches -C metadata → mono ordering)

memory-bank/techContext.md3,835 B

# Technical Context
## Technologies Used
### Core Technologies
- **Rust** - Primary programming language

- **WebAssembly (WASM)** - Compilation target for the contract

- **Alkanes Framework** - Smart contract framework for token implementation

- **MessageDispatch** - Macro for opcode-based message dispatching

- **alkanes-support** - Core support library for alkane contracts

- **alkanes-runtime** - Runtime support for alkane execution

- **metashrew-support** - Support library for metashrew compatibility

- **protorune-support** - Support for protorune protocol

- **alkane-factory-support** - Factory pattern support for token creation

- **ordinals** - Ordinals protocol integration

- **anyhow** - Error handling library

- **bitcoin** - Bitcoin protocol library

- **serde** - Serialization/deserialization framework

- **serde_json** - JSON support for serde

## Development Setup

### Project Structure

├── Cargo.toml - Project manifest

├── memory-bank/ - Documentation and context

├── reference/ - Reference implementations

│ └── owned.rs - Reference owned token implementation

└── src/ - Source code

├── constants.rs - Constant definitions

├── factory.rs - Factory implementation

└── lib.rs - Main contract implementation with MessageDispatch

### Build Configuration

The project is configured as both a cdylib (for WebAssembly compilation) and rlib (for Rust library usage):

crate-type = ["cdylib", "rlib"]

## Technical Constraints

### Compatibility Requirements

- Must be compatible with the MintableToken trait in the factory module

- Must follow the owned token opcode format for consistency

- Must support proper initialization sequence with authentication

- Must maintain backward compatibility with existing systems

### Security Requirements

- Must use proper initialization guard via observe_initialization()

- Must validate all numeric operations for overflow

- Must ensure transaction-bound mint limit is enforced cryptographically

- Must validate cap constraints before any mint operation

- Must prevent transaction replay attacks

### Performance Considerations

- Transaction hash storage must be efficient for large-scale usage

- Serialization/deserialization operations should be optimized

- Storage operations should be optimized to minimize resource usage

- Numeric operations must be checked for overflow to prevent vulnerabilities

- String operations use efficient encoding/decoding methods

## Integration Points

### Factory Integration

The contract implements the MintableToken trait to ensure compatibility with the factory module:

impl MintableToken for MintableAlkane {}

### Message Dispatch

The contract uses the MessageDispatch derive macro for opcode handling:

#[derive(MessageDispatch)]

enum MintableAlkaneMessage {

Initialize { /* ... */ },

// Other operations...

### Opcode Interface

The contract exposes a standardized opcode interface for external interaction:

- Standard operations (0, 77, 88, 99-101, 1000)

- Free mint specific operations (102-104)

- All operations have comprehensive documentation

### Storage Interface

The contract uses StoragePointer for persistent state management:

- Key-value storage for token properties

- Structured data storage for complex objects

- Transaction hash storage using HashSet and serde_json

## Deployment Considerations

- The contract is compiled to WebAssembly for deployment

- Initialization must be performed with proper parameters:

- Supply cap (0 for unlimited)

- Transaction hash storage should be considered for long-term usage patterns