Key Insights
- Starknet is set to become the first Layer-2 rollup to support settlement on both Ethereum and Bitcoin, marking a breakthrough in cross-chain infrastructure and execution-layer scalability.
- Built on STARK proofs and the Cairo VM, Starknet enables high-throughput, low-cost computation with quantum resistance and no trusted setup—scaling Ethereum since 2021 and soon to be extending to Bitcoin.
- Bitcoin integration is driven by deep R&D, including the Collider script, STARK verifiers on Signet, and a proposed OP_CAT upgrade that could enable fully trustless, native Bitcoin bridges.
- Starknet’s BTCFi initiatives and partnerships—such as the integration with Xverse wallet and BTCFi Season—aim to bootstrap Bitcoin-native DeFi and onboard BTC users into the Starknet ecosystem.
- Starknet’s development of STWO, its next-generation prover based on the Circle-STARK protocol, looks to improve proof speed, cost-efficiency, and compatibility with both Ethereum and Bitcoin environments.
Primer
Starknet is a permissionless, general-purpose Layer-2 (L2) scaling solution launched by StarkWare in November 2021. Built from the ground up for zero-knowledge proofs (ZKPs), Starknet diverges from traditional EVM-based L2s by introducing its own alternative virtual machine—the Cairo Virtual Machine (Cairo VM). This architecture marks Starknet as a leading force in the rise of altVMs, emphasizing performance, verifiability, and future-proof cryptographic security.
At the core of Starknet’s design is the ZK-Rollup model, where transactions are executed offchain and aggregated into succinct proofs—specifically STARKs (Scalable Transparent ARguments of Knowledge). These validity proofs are then published to Ethereum, ensuring correctness and minimizing gas costs on the base layer. Starknet’s infrastructure includes sequencers that order transactions and provers that generate the STARK proofs required for L1 verification.
Complementing this architecture is native account abstraction, a design choice that treats every user account as a smart contract by default. This enables advanced user flows, including passwordless authentication (e.g., email or biometric login), social recovery, multi-factor authentication, customizable transaction logic, and paymasters for gasless UX.
These features create a developer-friendly and user-centric environment, positioning Starknet as a robust foundation for next-generation applications.
STARKs represent a significant advancement over SNARKs and other ZKP systems by addressing key scalability, transparency, and long-term security limitations. Unlike SNARKs, STARKs use hash-based cryptographic primitives, which make them inherently quantum-resistant. STARK proofs are also highly scalable, capable of compressing the computation of millions of transactions into succinct validity proofs that can be verified onchain.
Together, STARK proofs, Cairo VM, and account abstraction enable Starknet to operate as a secure, high-performance, multi-chain execution layer.
To further improve proving efficiency, StarkWare introduced STWO, a next-generation, open-source zero-knowledge prover optimized for performance, cost, and flexibility. STWO is an evolution of the Stone prover, designed to leverage the capabilities of the Circle-STARK protocol, which removes key constraints that limited the original STARK protocol—Circle-Stark is a new proving architecture that introduces circular composition—allowing proofs to verify other proofs recursively, without requiring a trusted setup or sacrificing scalability. Its design is particularly suited to working efficiently with smaller fields. This breakthrough allows STWO to produce faster proofs with lower latency, making it especially impactful for applications that require quick finality and responsive UX. It also improves scalability by reducing proof size and generation time, enhancing the throughput potential of the Starknet network.
As Starknet expands to support Bitcoin and embraces multi-chain settlement, STWO plays a foundational role in enabling efficient proof generation that is compatible with both Ethereum and future Bitcoin-native verifiers.
Website / X (Twitter) / Discord
Starknet for Bitcoin: An Execution Layer for the World’s Largest Asset
Despite being the most secure and widely held digital asset, Bitcoin’s base layer is constrained by low throughput (~13 TPS), limited expressiveness, and a conservative development philosophy. These limitations have hindered Bitcoin from participating meaningfully in onchain innovation.
Starknet looks to unlock Bitcoin from its limitations by acting as Bitcoin’s execution layer, preserving Bitcoin’s settlement guarantees while extending its functionality via offchain computation and zero-knowledge proofs. Starknet addresses Bitcoin’s current restraints by processing transactions offchain and submitting succinct validity proofs back to Bitcoin, which increases transaction capacity and significantly reduces costs by minimizing the amount of data posted to the base layer. This allows Bitcoin to support a broader range of applications—without sacrificing its core principles of decentralization and security.
This would result in a Bitcoin-native, trustless environment capable of supporting decentralized applications, complex transactions, and smart contracts—without requiring centralized custodians or wrapped BTC. Starknet introduces a trustless, scalable alternative by:
- Settling STARK proofs directly to Bitcoin, compressing thousands of offchain transactions into a single onchain verification.
- Utilizing ZK-rollups to reduce fees and increase throughput dramatically.
- Introducing Cairo-powered smart contracts that leverage Bitcoin as a settlement and asset layer.
This allows Bitcoin to inherit application-layer expressiveness without compromising its base layer design principles and scaling up the Bitcoin blockchain to process many more transactions.
Starknet’s research into Bitcoin integration introduces the possibility of a new architecture, where in the future, Starknet could batch transactions, prove their validity with STARKs, and post these proofs to either Ethereum or Bitcoin, depending on user preference or application needs.
Bitcoin Covenants and OP_CAT
A central pillar of Starknet’s dual-settlement vision is the creation of secure, decentralized bridges that connect the Bitcoin and Ethereum ecosystems. While Ethereum’s smart contract architecture allows for trust-minimized interoperability, Bitcoin’s limited scripting environment presents a more complex challenge. Bridging Bitcoin requires a phased and technically rigorous approach that evolves in parallel with ongoing protocol-level advancements. Starknet plans to implement three stages to manage and create bridges to Bitcoin effectively.
In the short term, Starknet relies on federated bridges—custodial systems typically secured by multi-signature arrangements. Solutions like Xverse wallet allow users to interact with Starknet applications using BTC, offering convenience and early access to DeFi infrastructure. However, these bridges inherently rely on trusted intermediaries, which introduces centralization risks and runs counter to Bitcoin’s core ethos.
The medium-term strategy involves BitVM, an emerging design that enables offchain computation with onchain verification. By using Bitcoin scripts to enforce fraud-proof-based computation, BitVM bridges require only one honest participant to maintain trustlessness. This significantly reduces the need for custodians while staying within Bitcoin’s current capabilities.
Long term, Starknet’s most ambitious bridge design revolves around covenants, a class of smart contract-like scripts that define how and when Bitcoin outputs can be spent. While this capability is ideally enabled by the proposed activation of OP_CAT—an opcode upgrade that would re-enable byte string concatenation in Bitcoin’s scripting language—recent research has shown that similar functionality is possible today using Collider Scripts. Collider leverages hash collisions in Bitcoin’s existing opcodes to simulate recursive logic, enabling covenant-like behavior without needing new opcodes. However, this approach is extremely computationally expensive, making it impractical for production use at scale. OP_CAT would remove these limitations, unlocking recursive logic and dynamic constraints natively—key building blocks for expressive, programmable covenants and truly trustless Bitcoin bridges.
Unlike Bitcoin’s current setup—where coins are simply tied to a public key and can be spent by the owner—covenants introduce the ability to set rules on how and when coins can be spent. With the addition of OP_CAT, Bitcoin scripts could enforce conditions like: “this coin can only be spent if a certain input is present,” or “only if a specific proof or event has occurred.” In practical terms, this would allow Bitcoin to accept a withdrawal from Starknet only if it matches a previously approved state, creating a secure link between the two networks.
In Starknet’s long-term vision, Bitcoin could evolve beyond being a passive settlement layer to playing an active role in verifying offchain activity. If proposed upgrades like OP_CAT are adopted, a stark verifier could be implemented into Bitcoin’s scripting language, which would facilitate secure, self-custodial interactions between Bitcoin and Starknet, effectively creating a unified L2 solution that scales both Ethereum and Bitcoin. This would enable a fully trustless Bitcoin L2 environment, where Bitcoin itself enforces the correctness of cross-chain actions—without relying on custodians, multisigs, or third-party validators. While this functionality is not yet possible today, Starknet’s infrastructure is being developed with this future in mind.
To realize this vision, StarkWare is pioneering covenant-based infrastructure through a series of technical initiatives:
- Collider Script demonstrates how recursive covenants can be built using existing Bitcoin opcodes by leveraging hash collisions in SHA-1 and RIPEMD-160, allowing recursive logic without requiring OP_CAT.
- A bridge covenant prototype has been implemented in sCrypt, a high-level Bitcoin smart contract language. It supports batched deposits and withdrawals, Merkle proof validation, and recursive user account verification.
- StarkWare has also successfully conducted STARK proof verification on Bitcoin’s Signet testnet, establishing Bitcoin’s viability as a zk-proof verifier.
- The Bitcoin Wildlife Sanctuary project furthers this effort with open-source development of a Circle-STARK verifier and modular framework for building Bitcoin-native covenant contracts.
- STWO, StarkWare’s next-generation, open-source zero-knowledge prover based on the Circle-STARK protocol, supports these developments. STWO is optimized for low-latency, high-performance proof generation and designed to work efficiently with smaller fields, making it well-suited for enabling Bitcoin-native proof verification in the future.
Collectively, these developments aim to create a bridge framework where Bitcoin, not a third party, determines whether coins can be withdrawn based on offchain activity. Covenants serve as the enforcement layer, enabling smart contract-like behavior without altering Bitcoin’s consensus model.
Bridging Ethereum and Bitcoin
While many L2 solutions focus solely on EVM compatibility and scaling Ethereum in isolation, Starknet is exploring a broader design—one that could eventually support a multi-root rollup architecture anchored to both Ethereum and Bitcoin.
By extending trustless computation across Ethereum and Bitcoin, Starknet enables Ethereum-native tooling—such as DeFi protocols, account abstraction frameworks, and L2 developer stacks—to access Bitcoin’s liquidity without relying on custodial bridges or wrapped assets. In this model, Ethereum continues to provide the core smart contract functionality and coordination infrastructure, while Bitcoin serves as a high-value settlement layer.
This also creates new pathways for composability. Developers can build Ethereum-based applications that interact with native Bitcoin—or vice versa—within the same execution environment. Crucially, this unlocks trustless ETH to BTC asset-level composability, allowing users to directly use ETH and BTC in a single application flow—for example, providing BTC as collateral in an Ethereum-based lending protocol or executing atomic swaps between ETH and BTC without intermediaries.
The result is a more unified, efficient layer for multi-chain applications. For Ethereum, this allows for deepened utility. As more Bitcoin flows through trust-minimized Ethereum-based systems like Starknet, Ethereum strengthens its network effects as the smart contract layer for the broader crypto ecosystem.
Closing Summary
Starknet’s long-term vision of enabling native settlement on Ethereum and Bitcoin marks the broader adoption of blockchain interoperability. By extending its ZK-Rollup architecture, powered by quantum-resistant STARK proofs and the Cairo VM, Starknet is creating a scalable, secure, and user-friendly execution environment that bridges two of the largest blockchain networks. Its trustless integration with Bitcoin, made possible through novel covenant research and the anticipated OP_CAT upgrade, promises to unlock a new era of Bitcoin programmability that remains aligned with Bitcoin’s core principles. Starknet is scaling blockchains and redefining what interoperability can mean in a decentralized future through strategic partnerships, community engagement, and research-led development.
