Bitcoin Smart Contracts Without Runtime State

Native Bitcoin Script is non-Turing complete and has no runtime state, making complex applications impossible. Layer 2s like Lightning require active, stateful channels, limiting capital efficiency and programmability.

• State Explosion: Every active channel or contract locks up capital and requires constant monitoring.
• Limited Composability: Isolated state prevents contracts from interacting, stifling DeFi.
• High On-Chain Cost: Dispute resolution and channel management are expensive on L1.

Projects like BitVM and rollups use ZK proofs to commit to the result of off-chain computation, not the state itself. The chain only verifies a proof of valid state transition.

• Stateless Verification: A single proof can represent millions of state transitions, verified in ~10ms.
• Inherited Security: Fraudulent state is impossible to prove, inheriting Bitcoin's $1T+ security.
• Universal Bridge: Any off-chain VM (EVM, WASM) can be proven, enabling full DeFi and NFTs.

Pioneered by RGB and Taro, CSV moves all contract logic and state to the client. The Bitcoin ledger only holds cryptographic commitments, acting as a timestamped bulletin board.

• Massive Scalability: State growth is off-chain, enabling >100k TPS equivalent throughput.
• Strong Privacy: Contract details are only visible to involved parties, not the public chain.
• Single-Use Seals: Bitcoin UTXOs act as unique, non-reusable identifiers for off-chain state.

DLCs use oracles to enable Bitcoin-native conditional payments without a trusted third party. They are the simplest form of a stateless smart contract.

• Oracle-Based Logic: Outcomes are signed by pre-agreed oracles (e.g., Chainlink), unlocking funds.
• Minimal On-Chain Footprint: Only a single multisig transaction is ever broadcast, with ~200 bytes of data.
• Trust-Minimized: No custodial risk; users cannot lose funds unless all oracles collude.

Native Bitcoin contracts are limited, non-looping, and cannot manage complex, evolving state. This restricts DeFi, NFTs, and scalable dApps.

• No On-Chain State: Script cannot store or update data between transactions.
• Limited Logic: Operations are simple, preventing loops and complex conditions.
• Settlement-Only Layer: Bitcoin becomes a slow, expensive bulletin board for simple proofs.

A computing paradigm where complex logic executes off-chain between two parties, and Bitcoin's blockchain only verifies fraud proofs in disputes.

• Turing-Complete Off-Chain: Enables any computation in a challenge-response game.
• Minimal On-Chain Footprint: Only the initial commitment and rare fraud proofs hit L1.
• Inspired by Optimistic Rollups: Leverages the security model of Arbitrum and Optimism but for Bitcoin.

A protocol for issuing and transferring assets where all contract state and logic are stored and validated client-side, not on-chain.

• State is User-Held: Ownership and contract data live off-chain, referenced by Bitcoin UTXOs.
• Bulletin Board Use: Bitcoin transactions commit to state changes, not the state itself.
• Scalability & Privacy: Enables ~100k TPS off-chain and confidential assets via bulletproofs.

A separate blockchain that uses Bitcoin as its secure base layer via the Proof of Transfer (PoX) consensus mechanism.

• Clarity Smart Contracts: A predictable, secure language that executes on the Stacks chain.
• State Anchored to Bitcoin: Every Stacks block header is written to a Bitcoin transaction, inheriting finality.
• Ecosystem Growth: Hosts DeFi protocols like ALEX and NFTs, with ~$100M+ in bridged assets.

A simple, UTXO-native protocol for issuing fungible tokens on Bitcoin, designed as a successor to Ordinals.

• No Extra State: Token balances are encoded directly in UTXO transaction outputs.
• Ethereum-like Simplicity: Aims for user and developer familiarity compared to complex RGB.
• Efficient On-Chain Footprint: Leverages Bitcoin's existing data fields (OP_RETURN) without bloating the chain.

Stateless designs force a fundamental compromise: you cannot have Bitcoin's full security for complex, stateful execution.

• Verification ≠ Execution: Security is for settlement finality, not computation correctness.
• New Trust Assumptions: BitVM requires at least one honest participant; RGB requires data availability.
• The Scaling Trilemma Persists: These approaches mirror Ethereum's L2 trade-offs (e.g., Optimism, zkSync), but on Bitcoin.

Ethereum's global mutable state is its greatest scaling bottleneck and attack surface. Every transaction must be processed by every node, leading to ~$10B+ in MEV extraction annually and state bloat exceeding 1 TB. This model is fundamentally incompatible with Bitcoin's security-first design.

• State Bloat: Perpetual storage cost and sync time.
• MEV Surface: Mempool visibility enables front-running.
• Centralization Pressure: High hardware requirements for nodes.

Protocols like BitVM and RGB implement smart contracts as off-chain, client-side validation. The Bitcoin L1 only sees a commitment (e.g., a taproot leaf) and validates a zero-knowledge proof of correct state transition. This mirrors the intent-based architecture of UniswapX and CowSwap, moving complexity off-chain.

• L1 as Court: Bitcoin settles disputes, not computations.
• Deterministic Finality: No chain reorg risk for contract logic.
• Data Locality: Users manage their own state, eliminating global bloat.

This model repurposes Bitcoin into a minimalist data availability (DA) and ultimate settlement layer. Projects like Liquid Network and Stacks use sidechains for state, but the pure stateless vision (e.g., Citrea) uses Bitcoin solely to post state transitions and proofs. This is analogous to Celestia's modular design, but with Bitcoin's proven security.

• Security Inheritance: Contracts inherit Bitcoin's $1T+ security budget.
• Modular Stack: Execution and DA are decoupled.
• Censorship Resistance: Settlement on the most decentralized chain.

Statelessness shifts operational burden from validators to users. Clients must store their own state (UTXO set) and validate all relevant transactions, similar to running a light client. This enables ~1000x theoretical scalability but complicates UX. Wallets and indexers become critical infrastructure, creating new centralization vectors akin to Infura on Ethereum.

• UX Friction: Non-custodial requires active state management.
• New Infra Layer: Essential for indexing and proof generation.
• Privacy Upside: State is not broadcast globally by default.

BitVM (Compute) uses Bitcoin script to verify fraud proofs of off-chain computation, enabling arbitrary programs like optimistic rollups. RGB (Assets) uses client-side validation for scalable, confidential assets and contracts. They represent two points on a spectrum: BitVM for general computation, RGB for asset-centric logic. Both rely on Taproot and MAST for efficient commitment schemes.

• BitVM: Optimistic verification, fraud proofs, general purpose.
• RGB: Client-side validation, asset-focused, enhanced privacy.
• Core Tech: Both leverage Taproot/Merkelized Abstract Syntax Trees (MAST).

The logical conclusion is sovereign rollups where Bitcoin ensures data availability and consensus, but a separate network (e.g., a BitVM rollup chain) governs execution. This is the Celestia/Cosmos model applied to Bitcoin. Finality is social/economic, not automatic, but secured by Bitcoin's immutable ledger. This creates a multi-chain Bitcoin ecosystem without altering L1 consensus, akin to layerzero's omnichain vision but with Bitcoin as the root of trust.

• Sovereign Chains: Independent execution, Bitcoin-secured DA.
• Social Finality: Dispute resolution falls back to community.
• Ecosystem Expansion: Enables DeFi, NFTs, DEXs without L1 changes.