ACME Logo ACME

acme-protocol.md
Terminal
ACME-Technical.md
SDK-API.md
Validator-Specs.md
Testnet Live

ACME Protocol

Art Coded on the Monetary Engine: The Bitcoin-native metaprotocol solving fragmentation, verifiability, and permanence for digital art.

Explore Ecosystem Become a Partner
$4B+
BTC NFT Volume
50k+
Bitcoin Nodes
70%+
Creators on ETH
2026
Mainnet Launch

Why Build on ACME?

The infrastructure layer for Bitcoin's art ecosystem: Permanent, verifiable, and incentivized.

Digital Art Example

UTXO Fortress

Etch your art into Bitcoin's UTXO set using OLGA chunking. Permanent storage synced by every full node—over 50,000 globally.

NFT Illustration

Deterministic Verifiability

Sparse Merkle Trees and Canonical State Roots for cryptographic proofs. Verify ownership without trusting indexers.

NFT Mona Lisa

Mineable-UTXO Rewards

Fee pools reward validators for correct state computation. Turn indexing into a permissionless mining game with slashing for dishonesty.

NFT Illustration

Artist-Centered UX

Simple minting tools with tiered storage: UTXO for permanence, IPFS for efficiency. No Merkle trees for creators—just click and own.

NFT Illustration

Ecosystem Interoperability

Seamless bridges from Ordinals, Runes, Stamps, and Counterparty with verifiable proof of burns. One protocol, many assets.

Whitepaper

Deep dive into the ACME architecture, security model, and economic design.

  • ACME is a Bitcoin-native metaprotocol for digital art, addressing fragmentation, verifiability, and permanence issues in existing BTC NFT solutions.
  • Utilizes OLGA chunking for UTXO-based storage, Sparse Merkle Trees for proofs, and Canonical State Roots for deterministic verifiability.
  • Incentivizes validators through mineable-UTXO rewards and slashing, turning indexing into a permissionless economic game.
  • Provides artist-friendly tools with tiered storage (UTXO to IPFS) and seamless interoperability with Ordinals, Runes, Stamps, and Counterparty.
  • Testnet live; mainnet targeted for 2026, with grants for creators and developers.
  • OLGA Chunking: Breaks art data into UTXO-compatible chunks for permanent on-chain storage.
  • Sparse Merkle Trees (SMT): Efficient proofs for state inclusion/exclusion without full tree storage.
  • Canonical State Roots (CSR): Deterministic computation of global state for verifiable ownership.
  • Tiered Storage: UTXO for high-value permanence, IPFS for cost-efficient large files.
  • Interop Bridges: Atomic swaps and burns for migrating assets from other protocols.
  • Traditional DNS is vulnerable to single points of failure, regulatory pressure, and man-in-the-middle attacks; ACME eliminates these by distributing both the registry and resolution.
  • Blockchain-based registry maps stable domain names to dynamically updated verified node endpoints, requiring cryptographic authorization for updates.
  • Client resolution process involves querying the registry, verifying signatures, extracting active endpoints, and selecting based on strategies like load balancing.
  • On-chain commitments use Merkle roots to anchor state, with threshold signatures ensuring majority honesty.
  • Periodic validation confirms data correctness on-chain, while real-time monitoring checks node liveness and health.
  • Load balancing distributes traffic using weights adjusted by health metrics, supporting geographic optimization via anycast.
  • Client-side failover switches endpoints quickly if failures occur, enhancing reliability without central coordination.
  • The system tolerates Byzantine faults up to a threshold, protecting against malicious nodes.
  • Distribution must be trustless, enforced by Bitcoin's consensus rules, not off-chain agreements.
  • Fees aggregate into UTXOs locked with timelocks, requiring threshold signatures for release.
  • State commitments anchor canonical state via Merkle roots embedded in Bitcoin transactions.
  • Direct payout option sends rewards immediately to recipients; HTLC option uses hash-time locks for added security with secrets.
  • Single-winner model selects one recipient based on performance or lottery; multi-recipient distributes to several.
  • Treasury allocation reserves a share for protocol development, redeemable via simple scripts.
  • Fallback logic reverts unclaimed rewards to treasury after timelocks, preventing permanent lockup.
  • The architecture ensures efficiency with minimal on-chain complexity and low fees.
  • Preparation phase sets governance, reward splits, and winner criteria before fee collection begins.
  • Fee collection aggregates user payments into UTXOs over blocks, consolidated for distribution.
  • State finalization computes canonical state from ordered transactions and performance metrics.
  • Commitment transaction broadcasts aggregated state with signatures if threshold met.
  • Reward claim phase allows winners to unlock outputs post-confirmation.
  • In offline failure, treasury recovers unclaimed funds after timelock without permanent loss.
  • Byzantine collusion attempt fails if signatures don't meet threshold, preventing invalid distributions.
  • Monitoring detects anomalies like unexpected outputs for community response.
  • On-chain overhead amortizes fees across many transactions, with per-commitment cost around 300 bytes.
  • For high-frequency epochs, more secure proofs increase costs but remain viable.
  • Large indexer sets raise signature size but can split into subgroups for scalability.
  • Many recipients increase transaction size proportionally, potentially hitting block limits.
  • Trade-offs: Shorter epochs offer faster accumulation but higher fees; HTLC vs direct adds cryptographic guarantees at extra cost per recipient.
  • Overall, batching via epochs makes periodic commitments economically sustainable.
  • Threat model assumes adversaries control up to M-1 indexers, operate malicious nodes, or experience partitions.
  • DNS security authenticates endpoints with threshold signatures, tolerating temporary failures.
  • Fee distribution integrity uses timelocks to prevent premature withdrawal, with proofs ensuring only valid claims.
  • Byzantine tolerance requires M signatures, protecting against dishonest minorities.
  • Failure mitigations include fallbacks for no commitments and governance for persistent issues.
  • Bitcoin consensus prevents distinguishing valid from invalid off-chain without cryptographic checks.
  • Centralized (Infura): Simple but single failure point and censorship risks; ACME distributes to avoid this.
  • Federated (Polkadot/Cosmos): Decentralized validators but requires external chains; ACME uses Bitcoin directly.
  • DAO Treasury: Transparent logic but adds dependency on other chains; ACME is Bitcoin-native with no tokens.
  • Key management for thresholds uses multi-party computation to generate keys securely.
  • Clients cache endpoints, implement failover, and verify proofs for security.
  • Monitoring pings nodes, tracks uptime, and alerts on degradations or invalid signatures.
  • Signing coordinator could automate but remains optional for decentralization.
  • ACME demonstrates feasible, practical decentralized infrastructure on Bitcoin without external dependencies.
  • It enables trustless API discovery and fee distribution scalable with transaction volume.
  • Byzantine fault tolerance protects against malicious actors while remaining practical.
  • Verifiable correctness through on-chain commitments provides objective proofs.
  • Economic sustainability batches rewards to minimize fees, aligning incentives.

Technical & Ecosystem Overview

Everything you need to build, create, and scale on ACME — in one place.

  • Protocol Specification: Full OLGA encoding, CSR roots, Merkle proofs, and state transitions.
  • Tutorials: Minting, validating, migrating assets from ETH/Ordinals.
  • Code Examples: Rust, Go, JavaScript indexers and wallet integrations.
  • API Reference: REST and WebSocket endpoints for real-time state.

Core Spec

OLGA chunking, deterministic state, proof formats.

Guides

From zero to minting in 5 minutes.

  • acme-cli: Mint, validate, and manage assets from terminal.
  • JavaScript SDK: Web-first integration for marketplaces and dApps.
  • Rust & Go Indexers: Run your own validator with full test vectors.
  • Testnet Faucet: Free test BTC and assets for development.

CLI

acme mint --tier utxo art.png

JS SDK

npm install @acme-protocol/sdk

  • Audited Core: State machine and OLGA parser by top security firms.
  • Bug Bounty: ACME funded for critical vulnerabilities.
  • Slashing: Validators lose rewards for dishonest state proofs.
  • Transparent Monitoring: Public dashboards for node health and attestations.

Audit Status

100% core modules audited

Bounty Program

Active on Immunefi

  • Mint Studio: Drag & drop minting with UTXO/Taproot/IPFS tiers.
  • ARTCORE Curation: Museum-grade collections with provenance.
  • Migration Portal: Burn on ETH → reissue on ACME with grant.
  • Creator Dashboard: Analytics, royalties, and provenance tracking.

Mint

No code. Just art.

ARTCORE

Curated collections

  • UniSat / Xverse: Native ACME support in forked wallets.
  • Marketplaces: DEX, royalties, order books via CSR proofs.
  • Enterprise APIs: Real-time provenance and analytics.
  • Cross-Protocol Indexing: Ordinals, Runes, Stamps, Counterparty.

Wallets

UniSat, Xverse, Leather

Markets

Magic Eden, Gamma

  • Creator Grants: ACME funded for migration and new collections.
  • Dev Grants: Build tools, indexers, wallets — get funded.
  • Validator Grants: Early node operators earn bonus rewards.
  • Application Portal: Open year-round with rolling reviews.

Creators

Migrate & mint free

Builders

Get paid to ship

Roadmap

Our journey to revolutionize digital art on Bitcoin.

Laying the foundation for the creative revolution. Building the tools that give artists true ownership and永久 permanence on Bitcoin.

  • ⚡ MVP Development: Crafting the core protocol that embeds art directly into Bitcoin's eternal ledger
  • 🎨 Angel Round: Gathering visionaries who believe in empowering creators and building the federation
  • ✨ Closed Beta: First creators experiment with true Bitcoin-native art ownership
  • 🔮 Foundation Indexer: The initial gateway to accessing eternal art on-chain

Opening the gates to creators worldwide. Building an unstoppable movement of artists who refuse to compromise on ownership.

  • 💎 Presale Launch: Early believers secure their stake in the creative economy of tomorrow
  • 🎭 Public Beta: Refined tools for seamless art creation and discovery experience
  • 🌊 Public Testnet: Playground for artists, collectors, and builders to experiment freely
  • 🚀 Growth Campaigns: Galxe activations, creator incentives, and building the federation network
  • 🔥 Community Fire: Spreading the gospel of true digital ownership across the creator economy

The revolution goes live. Art becomes eternal. Creators become sovereign. Bitcoin becomes the canvas for humanity's creativity.

  • 💥 Token Generation Event: ACME comes alive on Bitcoin, fueling the creative economy
  • 🌟 Mainnet Alpha: The protocol is live, permanent, unstoppable—art on Bitcoin forever
  • 👑 Name Registry: Claim your eternal identity in the Bitcoin art universe
  • 🎨 Collections Go Live: Curate, create, and immortalize your artistic vision on-chain
  • 🪙 Fungible Token Creation: Artists launch their own economies, communities, and currencies
  • 🌍 Global Movement: Onboarding creators, galleries, collectors—the art world discovers Bitcoin

Power to the people. The federation emerges. Partners, believers, and creators unite to run the infrastructure that serves everyone.

  • 🌐 Federation Activation: Partners and investors spin up nodes, distributing power globally
  • 🔗 Decentralized API: No single point of control, no single point of failure
  • ⚖️ Node Incentives: Federation members rewarded for serving the creative community
  • 🗳️ Governance Framework: Collective decision-making for protocol evolution
  • 🚀 Protocol Evolution: Community-driven features, optimizations, and innovations

The endgame: A completely permissionless, unstoppable creative platform governed by those who believe in it. No gatekeepers. No middlemen. No compromises. Just artists, collectors, and builders creating the future of digital art on the most secure, most decentralized ledger humanity has ever known. Run a node. Build tools. Create art. Shape governance. This is the infrastructure that serves creation itself—eternal, immutable, and free.

Join the ACME Ecosystem

Partner with us to unify Bitcoin's art landscape: Artists, developers, galleries, and institutions.

Artists & Creators

Migrate from Ethereum or other protocols with grants. Use ARTCORE for curation and white-glove onboarding.

Apply for Grants

Developers & Builders

Open-source indexers in Rust/Go, SDKs, test vectors. Build wallets, marketplaces, and tools on our deterministic state.

Get SDK

Galleries & Institutions

Enterprise APIs for provenance, curation slots in ARTCORE, museum-grade verification for collections.

Integrate APIs

Wallet & Marketplace Partners

Integrate with UniSat/Xverse forks. Offer DEX, royalties, and verifiable state to your users.

Partner Up
acme-cli@latest

Contact Us

Let us know how you'd like to get involved with ACME.