Atlas PAB: Native Bitcoin (BTC) Integration Layer

[Proposal setup] Proposal title

Please provide your proposal title

Atlas PAB: Native Bitcoin (BTC) Integration Layer

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

100000

[Proposal Summary] Time

Please specify how many months you expect your project to last

8

[Proposal Summary] Problem Statement

What is the problem you want to solve?

Cardano lacks native Bitcoin integration tooling, forcing dApp developers to rely on wrapped BTC or custodial bridges, compromising decentralization, security, and trustlessness.

[Proposal Summary] Supporting Documentation

Supporting links

• https://atlas-app.io/

[Proposal Summary] Project Dependencies

Does your project have any dependencies on other organizations, technical or otherwise?

No

Describe any dependencies or write 'No dependencies'

No dependencies

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

License and Additional Information

Apache 2.0

[Theme Selection] Theme

Please choose the most relevant theme and tag related to the outcomes of your proposal

Developer Tools

[Campaign Category] Category Questions

Mention your open source license and describe your open source license rationale.

We will license all deliverables under the Apache License 2.0, a highly permissive open source license that allows anyone to use, modify, distribute, and integrate the code — including for commercial use — without restriction. This license also provides an explicit patent grant and does not require derivative works to be open-sourced. It encourages wide adoption while preserving contributor credit and code integrity. This aligns with our commitment to openness, decentralization, and enabling innovation across the Cardano and Bitcoin ecosystems.

How do you make sure your source code is accessible to the public from project start, and people are informed?

We will publish all code to a public GitHub repository under the Apache 2.0 license. The repository will be accessible from the beginning, with iterative commits and tagged releases throughout development. The repo will be linked from Genius Yield’s official channels (website, Twitter, Discord, and Catalyst updates). Regular development updates and community demos will keep developers and users informed, ensuring transparency and adoption from day one.

How will you provide high quality documentation?

We will provide comprehensive documentation through a dedicated /docs section in the GitHub repository, covering architecture, API references, configuration, usage examples, and tutorials. All modules will be annotated with inline comments and supplemented with markdown-based developer guides. The Developer Advocate will maintain and update the documentation throughout the project lifecycle, and a full tutorial for the BTC-aware dApp will be published alongside testnet deployment to ensure accessibility for all users.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

We propose to upgrade the Atlas Plutus Application Backend (PAB) into a fully Bitcoin-aware middleware platform that empowers Cardano developers to integrate native Bitcoin (BTC) transactions into their decentralized applications — without wrapped assets or centralized bridges. This is made possible through a modular integration layer designed around the UTXO compatibility shared by both Bitcoin and Cardano.

Core Components of the Atlas.Bitcoin Integration Layer

Bitcoin Monitor Module

We will build a pluggable module within Atlas to track Bitcoin transactions and UTXOs in real time. This will support:

Monitoring BTC addresses and scripts of interest

Watching UTXO states via full Bitcoin Core nodes, Electrum servers, or Esplora APIs

Generating real-time events based on confirmed BTC activity

This enables Cardano applications to observe external BTC events securely, without relying on centralized APIs.

BTC-to-Plutus Trigger Framework

We will develop a declarative JSON/DSL (domain-specific language) system that lets developers define Bitcoin-based triggers for Plutus contracts. For example:

json :

{

"btc_address": "bc1qxyz...",

"amount": 0.05,

"confirmations": 3,

"on_match": "execute_plutus_endpoint('mint_stablecoin')"

}

This means BTC payments or UTXO state changes can trigger:

Token mints

Contract executions

NFT reveals

DAO votes or donations

Escrow releases

This makes Cardano dApps reactive to Bitcoin without compromising decentralization.

BTC Proof Verification Layer

This component will allow dApps to verify BTC transactions and state changes cryptographically before interacting with Cardano contracts. We’ll support:

SPV proofs (Simple Payment Verification)

Babylon-style proofs (BTC finality signals)

BitVM (Bitcoin-native logic execution layer)

These will be validated either off-chain (in the backend) or via Plutus-compatible witness mechanisms, enabling light client interactions with high trust.

Metadata and Asset Tracker

This Atlas plugin will allow developers to:

Link BTC txids or UTXOs to Cardano assets (e.g., stablecoins, NFTs)

Store these mappings in Atlas’s internal index

Expose REST APIs to query them from frontend UIs

Use cases include: BTC-for-NFT auctions, BTC-collateralized loans, BTC-powered token minting, and more.

Demonstration dApp

We will build and open-source a fully functional BTC-aware dApp to showcase the integration layer. Example scenarios include:

BTC-backed stablecoin minting system (BTC triggers minting of native Cardano token)

NFT auction triggered by BTC payment (no custodial bridge)

BTC DAO contributions recorded on Cardano

This app will:

Run on testnet

Include a web UI

Be documented for devs to fork/extend

Be available for live community demos and testing

[Your Project and Solution] Impact

Please define the positive impact your project will have on the wider Cardano community

The Atlas PAB: Native Bitcoin Integration Layer will have a transformative impact on the Cardano ecosystem by unlocking native, trustless access to the world’s most valuable digital asset—Bitcoin—without relying on wrapped assets or centralized bridges. This project enables entirely new classes of decentralized applications on Cardano that can natively react to Bitcoin transactions, vastly expanding what developers can build.

By introducing BTC-aware smart contract tooling, this integration empowers:

DeFi protocols to use Bitcoin as collateral, enabling stablecoins, lending, and automated market-making with BTC as a base asset

NFT marketplaces to accept native BTC payments directly on Cardano

DAOs and donation systems to collect BTC and trigger governance or treasury logic

Developers to write cross-chain logic in a familiar backend (Atlas) without needing to reimplement infrastructure

BTC holders to participate in Cardano dApps without giving up custody or wrapping tokens

This project will foster cross-chain liquidity, expand developer capabilities, and attract new users and capital to the Cardano ecosystem — particularly from the Bitcoin community that values decentralization and self-custody.

Additionally, as Atlas is open-source and already widely used within the ecosystem, this enhancement will propagate across multiple projects, including wallets, launchpads, and DeFi platforms. It will also serve as a foundational building block for trustless cross-chain coordination, aligning with Cardano’s vision of a decentralized financial future.

this initiative strengthens Cardano’s position as the most advanced and secure UTXO-based smart contract platform — not only interoperable with Bitcoin, but also capable of building with it natively.

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

Atlas PAB is the main contributor of Atlas 1.0 and Atlas 2.0 ( Catalyst F12 ) and possesses deep knowledge and understanding of the PAB architecture. Its track record demonstrates that the team is more than capable to execute on the deliverables of Atlas BTC integration layer.

[Milestones] Project Milestones

Milestone Title

Atlas.Bitcoin Plugin Module

Milestone Outputs

Develop the foundational Bitcoin integration module for Atlas. This plugin will enable off-chain tracking of Bitcoin UTXOs, scripts, and transactions using data from Bitcoin Core, Electrum, or Esplora APIs. The module will expose APIs to:

Monitor specified Bitcoin addresses

Watch UTXO state changes

Emit structured events for downstream Atlas triggers

This milestone provides the essential backend tooling to observe Bitcoin natively and forms the backbone for all further BTC-triggered logic.

Acceptance Criteria

Atlas can subscribe to and monitor BTC addresses or scriptPubKeys

Events are emitted upon BTC transaction detection and UTXO updates

Works with Bitcoin Core, Electrum, or Esplora backends (configurable)

Includes unit tests for UTXO monitoring and event generation

BTC testnet demo shows monitoring of at least 2 addresses with working events

Evidence of Completion

Open-source code published in the official Atlas GitHub repo under Apache 2.0

Configurable plugin settings documented (e.g., node type, address list)

Screenshots or logs showing successful BTC UTXO tracking

Sample testnet run demonstrating detection of BTC testnet transactions

CLI or HTTP endpoint outputs validating the plugin’s functionality

Unit test coverage report

Delivery Month

2

Cost

20000

Progress

20 %

Milestone Title

BTC Trigger Framework

Milestone Outputs

Develop a JSON/DSL-based trigger framework within Atlas that allows developers to define logic that reacts to native Bitcoin events. This system will let dApp builders describe BTC conditions (e.g., amount, confirmations, address) that, once satisfied, automatically activate Cardano Plutus contract endpoints. Triggers will be linked to Atlas Plutus endpoints and managed securely off-chain. The framework will include:

Trigger schema definition and validation

Trigger execution engine

Integration with the BTC monitor plugin

Testnet-ready examples

Acceptance Criteria

Developers can define BTC triggers in JSON or DSL format

Trigger engine parses, stores, and watches registered triggers

Upon BTC event match, the trigger executes a Plutus endpoint call

Works with testnet BTC payments and simulated smart contract endpoints

Trigger system handles error cases (invalid trigger, failure to match, etc.)

Unit tests and scenario tests validate core logic

Evidence of Completion

GitHub release including trigger engine code and example configurations

Screenshots or logs of a trigger being activated by a BTC testnet transaction

Demo showing a BTC payment triggering a Cardano contract via Atlas

Documentation describing how to write, deploy, and test triggers

CLI and/or web interface for registering and viewing trigger status

Test coverage report confirming framework reliability

Delivery Month

2

Cost

20000

Progress

40 %

Milestone Title

BTC Proof Verifier Support

Milestone Outputs

This milestone delivers a modular proof verification layer within Atlas that validates Bitcoin transaction proofs to ensure trustless off-chain verification of BTC state. The system will support:

SPV proofs: Verifies inclusion of a BTC transaction in a valid Bitcoin block.

Babylon-style proofs: Finality signals anchored in BTC.

BitVM-style logic (if viable within scope): Enables smart contract-compatible logic proofs based on Bitcoin transactions.

The verifier will allow developers to submit BTC proofs for validation and optionally link them to contract logic within Atlas. The module will be implemented in Haskell and tested using BTC testnet transactions.

Acceptance Criteria

Implements SPV proof verification against real Bitcoin block headers

Supports parsing and validating proof formats (SPV, Babylon, or BitVM-style)

Can verify BTC testnet transactions using standard Merkle inclusion proofs

Accepts inputs via CLI or API for submission and validation

Verifier is pluggable and accessible from the Atlas trigger framework

Validated proofs can be attached to trigger actions or stored for audit

Passes test suite covering valid/invalid cases, edge cases, and malformed proofs

Evidence of Completion

Haskell module committed to Atlas GitHub repo with documentation and example usage

Scripts or CLI commands for generating and submitting BTC testnet SPV proofs

Unit and integration test coverage with BTC testnet TXs

Logs or screenshots showing proof validation success/failure outcomes

Documentation page on how to use/verifiy SPV or Babylon proofs within Atlas

Example demo where proof verification triggers a simulated contract flow

Delivery Month

2

Cost

20000

Progress

60 %

Milestone Title

BTC Metadata Tracker

Milestone Outputs

This milestone will deliver a metadata tracking system within Atlas that links Bitcoin transaction IDs (txids) or UTXOs to Cardano-side assets, events, or identifiers. This enables dApps to build trustless BTC-aware workflows (e.g., NFTs minted in response to BTC payments, BTC-collateralized assets, or asset registries anchored to BTC txids).

The system will:

Store mappings between BTC txids and Cardano asset IDs or Plutus contract events

Expose these mappings via Atlas APIs for indexing or frontend display

Support tagging and timestamping of metadata entries for traceability

Allow developers to query historical BTC-to-Cardano associations

This module enhances transparency and supports dApps needing persistent, queryable links between Bitcoin and Cardano layers.

Acceptance Criteria

Developers can register BTC txid + metadata mappings via CLI or API

Stored metadata can include asset ID, Plutus contract ID, timestamps, tags

REST API endpoint exposes stored metadata entries by txid or asset ID

System supports simple search and retrieval functions

Demonstrated on testnet with BTC testnet txids linked to Cardano test assets

Passes tests for registering, retrieving, and querying stored entries

Evidence of Completion

Source code committed to Atlas GitHub repo under Apache 2.0

CLI or HTTP endpoints for registering and retrieving metadata

JSON examples showing metadata payloads stored and retrieved

Sample output mapping BTC testnet txids to Cardano asset fingerprints

Documentation for developers on integrating metadata in dApps

Test coverage report verifying core metadata functions

Delivery Month

1

Cost

20000

Progress

80 %

Milestone Title

Example BTC-aware dApp + UI

Milestone Outputs

Deliver a working example dApp that integrates all previously developed modules to showcase a real-world use case of Bitcoin-triggered smart contracts on Cardano. The dApp will include:

A user interface (UI) built with a web framework compatible with Cardano wallets (e.g., Nami, Eternl)

BTC testnet integration for receiving Bitcoin payments or signals

Smart contract logic executed on Cardano in response to BTC events

A use case such as:

Minting a stablecoin backed by BTC

BTC-for-NFT auction settlement

BTC DAO donation tracker

The UI will serve both as a demonstration for users and a developer reference app.

Acceptance Criteria

UI connects to Cardano wallet and interacts with deployed Plutus contracts

BTC testnet transactions trigger visible and auditable actions on Cardano

Demonstrated use case includes all modules: BTC monitor, trigger engine, proof verifier, and metadata tracker

dApp runs on public testnet with user instructions and hosted frontend

Source code is open-source and includes a README for local deployment

Users can complete a full flow: send BTC → trigger event → see Cardano response

Evidence of Completion

GitHub repo with frontend and backend code, README, and setup instructions

Hosted testnet app demo (e.g., via GitHub Pages, Netlify, or Vercel)

Video walkthrough of the user flow from BTC payment to Plutus execution

Testnet transaction hashes for BTC payments and resulting Cardano actions

UI screenshots and logs confirming integration success

Public announcement (e.g., blog, Twitter, Discord) inviting community testing

Delivery Month

1

Cost

20000

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

Milestone 1: Atlas.Bitcoin Plugin Module

Enable BTC UTXO tracking and monitoring via Bitcoin Core/Electrum/Esplora

Role Tasks Devs Hours ADA Allocation

Haskell Developer Build plugin to connect Atlas with BTC sources : 9,000 ADA

Systems Engineer Integration with Bitcoin node/light client : 5,000 ADA

QA Engineer Internal test coverage, regression testing : 2,500 ADA

Technical Writer Setup guide + code examples : 1,500 ADA

PM & Coordination Standups, review cycles :2,000 ADA

Total 20,000 ADA

Milestone 2: BTC Trigger Framework

Allow devs to define BTC-based triggers for activating Plutus endpoints

Role Tasks Devs Hours ADA Allocation

Haskell Developer Build JSON/DSL-based trigger logic : 9,000 ADA

Protocol Engineer Event dispatch integration with Plutus endpoints : 5,000 ADA

QA Engineer Simulate BTC triggers, ensure reliability : 2,500 ADA

Technical Writer DSL documentation and dev usage examples :1,500 ADA

PM & Coordination Review cycles, user feedback loop :2,000 ADA

Total : 20,000 ADA

Milestone 3: BTC Proof Verifier Support

Goal: Verify SPV/Babylon/BitVM proofs in off-chain clients

Role Tasks Devs Hours ADA Allocation

Cryptography Engineer SPV/Babylon proof verifier implementation : 8,000 ADA

Haskell Developer Atlas integration + logic binding : 6,000 ADA

QA Engineer Test invalid/malicious proofs, security edge cases : 3,000 ADA

Technical Writer Proof verification usage guide : 1,500 ADA

PM & Coordination Resource allocation and repo delivery : 1,500 ADA

Total : 20,000 ADA

Milestone 4: BTC Metadata Tracker

Goal: Track BTC txids and link metadata to Cardano assets in Atlas

Role Tasks Devs Hours ADA Allocation

Haskell Developer Write metadata linking module : 7,000 ADA

DB Engineer Schema support for BTC-asset linkage : 4,500 ADA

QA Engineer Functional testing of tracker and metadata storage : 3,000 ADA

Technical Writer API and metadata schema docs : 1,500 ADA

PM & Coordination Sprint planning and doc publishing : 4,000 ADA

Total : 20,000 ADA

Milestone 5: Example BTC-aware dApp + UI

Goal: Showcase use-case like BTC-for-NFT auction with front-end and documentation

Role Tasks Devs Hours ADA Allocation

Full-stack Developer Build frontend UI + backend dApp flow : 9,000 ADA

Smart Contract Dev Connect dApp logic with BTC triggers : 4,500 ADA

Developer Advocate Tutorial writing, video walkthrough : 2,000 ADA

QA Engineer E2E flow test on testnet 1 10 1,500 ADA

PM & Community Test Testnet setup, Discord feedback loop : 3,000 ADA

Total : 20,000 ADA

Total : 660 hours for 100,000 ADA

[Final Pitch] Value for Money

How does the cost of the project represent value for the Cardano ecosystem?

This project delivers exceptional value to the Cardano ecosystem by enabling Bitcoin-aware dApps and bridging BTC triggers directly into Plutus smart contracts. For just 100,000 ADA, the proposal introduces reusable open-source infrastructure—modules, verifiers, and a reference dApp—that empower any Cardano developer to build applications responsive to Bitcoin events. This unlocks entirely new DeFi primitives, liquidity models, and interoperability use cases. By lowering technical barriers and accelerating innovation, this initiative significantly amplifies Cardano's utility, competitiveness, and cross-chain adoption at a fraction of traditional R&D cost.

[Required Acknowledgements] Consent & Confirmation

Terms and Conditions:

Yes