Bitcoin Scaling Shrinks the Trustless Surface

Bitcoin's core security model—global, synchronous consensus—limits throughput to ~7 TPS. Scaling on-chain requires altering the base layer's trust assumptions, which the network has historically rejected.

• Security Primacy: Nakamoto Consensus is the ultimate trust anchor.
• Throughput Ceiling: ~4-7 transactions per second.
• Resource Cost: Full nodes must validate everything, forever.

Offload transactions to secondary networks that settle to Bitcoin. This trades the base layer's universal trust for smaller, faster trust clusters.

• Lightning Network: Creates off-chain payment channels with instant finality and ~1M+ TPS network capacity.
• Sidechains (e.g., Liquid): Use a federated multi-sig for faster blocks, sacrificing decentralization for ~2 min finality.
• Trust Surface: Users trust the L2's cryptographic and/or economic security model.

A Layer 1 upgrade that allows users to opt into new rulesets without forcing them on all nodes. It expands Bitcoin's functionality while preserving the core chain's sovereignty.

• Drivechains: Use a soft fork to enable blind merged mining, letting sidechains borrow Bitcoin's hash power.
• Ark / BitVM: Use zero-knowledge proofs and fraud proofs to enable off-chain contracts, moving complexity to the client.
• Trust Surface: Users must validate the state of their specific covenant or sidechain.

Use Bitcoin's native cryptographic security as a trust root for other chains, turning it into a staking and restaking asset. This exports Bitcoin's security rather than scaling its execution.

• tBTC: Overcollateralized and decentrally governed bridge to Ethereum.
• Babylon: Enables Bitcoin timestamping and staking to secure PoS chains via slashing.
• Trust Surface: Users trust the economic security of the overcollateralization or the slashing mechanism.

Lightning's security model relies on users or third-party watchtowers to be online to punish fraud. This introduces a liveness assumption and operational overhead, shrinking the user base to the technically adept.

• Trust Assumption: Liveness of a watchtower or your own node.
• Attack Surface: Old-state fraud if counterparty goes offline.
• User Burden: Requires constant monitoring or delegation.

Drivechains, like those proposed by LayerTwo Labs, use a federation of Bitcoin miners as a soft-consensus committee to validate sidechain withdrawals. This trades pure cryptographic trust for a weaker, but still Bitcoin-native, economic assumption.

• Trust Assumption: Honest majority of Bitcoin hash power.
• Architectural Gain: Enables complex, slow-finality sidechains (e.g., for DeFi).
• Trade-off: Introduces a new, miner-mediated governance layer.

Projects like Citrea and BitVM use Bitcoin as a data availability and dispute resolution layer. Execution moves off-chain, but fraud proofs or validity proofs can be settled on L1. This minimizes active trust while maximizing L1 security.

• Trust Assumption: At least one honest verifier (for fraud proofs).
• Key Innovation: Leverages Bitcoin's ~$1T security for data, not computation.
• Result: Enables EVM-compatible throughput without new validator sets.

The Liquid Network uses a known federation of institutions to operate a Bitcoin sidechain. It's the least trust-minimized model but delivers confidential transactions and ~2-minute finality today.

• Trust Assumption: Honest majority of the 15-functionary federation.
• Use Case: High-value, time-sensitive settlements for exchanges and institutions.
• Reality Check: A $10B+ TVL ecosystem built on explicit, auditable trust.

Directly using Bitcoin's base layer for DeFi or high-frequency transactions is economically impossible. The ~7 TPS limit and ~10-minute block times create a massive trust surface for any multi-step protocol, forcing reliance on centralized sequencers or custodians.

• Trust Assumption: Users must trust a third party to manage state off-chain.
• Capital Inefficiency: Billions in liquidity sit idle waiting for slow, expensive finality.

Protocols like Stacks (sBTC) and BitVM-based chains use Bitcoin as a pure data availability and dispute resolution layer. Execution moves off-chain, shrinking the active trust surface to cryptographic fraud or validity proofs.

• Trust Minimized: Security inherits from Bitcoin's L1, not a new validator set.
• Scalability Achieved: Enables 1000+ TPS and ~2-second pre-confirmations for applications.

Moving assets between Bitcoin L1 and scaling solutions reintroduces massive custodial or governance risk. Bridges like Multichain have failed, proving that a $2B+ TVL system is only as strong as its weakest link—often a multi-sig.

• Centralization: Most bridges rely on a federated committee of known entities.
• Systemic Risk: A bridge hack compromises the entire scaling ecosystem's liquidity.

The endgame is eliminating third-party bridges. sBTC aims for a 1:1, programmable Bitcoin representation secured by Stack's miners. Babylon proposes using Bitcoin staking to secure light client sync for other chains, enabling trust-minimized cross-chain communication.

• Non-Custodial: Users retain control of keys throughout the peg process.
• Capital Efficient: Unlocks Bitcoin's $1T+ dormant capital for DeFi without wrapping.

Each new Bitcoin scaling solution creates its own siloed liquidity pool and developer environment. This fragmentation kills the network effects that make Ethereum L2s like Arbitrum and Optimism viable, leading to poor UX and inefficient capital allocation.

• Siloed State: Apps on Chain A cannot natively interact with assets on Chain B.
• Developer Friction: No standard tooling or shared security model across ecosystems.

Adopting a shared sequencer network (like Astria or Espresso) for multiple Bitcoin rollups can enable atomic cross-rollup composability and MEV resistance. A Bitcoin Improvement Proposal (BIP) for a standard bridge/peg could unify the ecosystem, similar to ERC-20's role.

• Atomic Composability: Enables complex, cross-chain DeFi transactions.
• Unified Liquidity: Creates a single, deep market across all participating L2s.