
An In-Depth Introduction to RGB, BitVM, and Nostr
Authors: Zhejiang University Blockchain Association, BiHelix, ScaleBit & BTC Security Lab
Intro: Why BTC L2
The explosive growth of the inscription ecosystem in 2023 rapidly elevated the priority of Bitcoin's scalability issues. Colored coin schemes—methods that attach metadata to Bitcoin transactions to assign additional attributes or meaning (e.g., BRC20)—have caused congestion on native Bitcoin transactions. As a key solution to this problem, BTC Layer 2 (L2) is set to become a central narrative in 2024. This article explores three promising BTC L2 solutions: RGB, BitVM, and Nostr built atop the Lightning Network.
RGB Protocol
What is RGB?
RGB is a scalable and confidential smart contract protocol designed for Bitcoin and the Lightning Network, developed by the LNP/BP Standards Association. It leverages private and shared ownership models and operates as a Turing-complete, trustless form of distributed computing. Unlike traditional blockchains, RGB does not rely on a network or blockchain structure. Instead, it is a client-side validated partial-state smart contract system, where state validation occurs off-chain through client-side verification.
History of the RGB Protocol
Origins of RGB
RGB was initially conceptualized in 2016 by Giacomo Zucco from BHB Network as a "blockchain-less asset system." That same year, Peter Todd introduced the concepts of Single-Use Seals and Client-Side Validation, which became foundational to RGB’s design. Inspired by these ideas, RGB was formally proposed in 2018. In 2019, core developer Maxim Orlovsky began leading the project, contributing to nearly all aspects of the protocol's codebase and standardization. Together with Zucco, he co-founded the LNP/BP Standards Association (https://www.lnp-bp.org), dedicated to advancing RGB from concept to real-world application. The association has received support from Fulgur Ventures, Bitfinex, Hojo Foundation, Pandora Prime, and DIBA. After extensive development, RGB released version V0.10 in April 2023—the first stable and usable release. As of January 2024, core developers have announced plans to launch version V0.11 in the first half of the year.

Latest Developments in RGB
Detailed analyses of RGB V0.10’s new features are already available elsewhere. Here, we highlight upcoming updates and community developments related to the anticipated V0.11 release:
- Support for L-BTC will be added
- Interoperability and cross-chain bridges between RGB assets and Liquid assets will be enhanced
However, RGB V0.11 will not be backward compatible with V0.10, resulting in significant migration costs for existing projects. Combined with slow development progress, many teams are currently waiting for V0.11 before proceeding.
Design Philosophy and Operating Principles of RGB
RGB employs client-side validation, meaning all data resides off-chain—outside the Bitcoin blockchain or Lightning channel states. This allows RGB to operate over the Lightning Network without requiring changes to Bitcoin’s base layer or Lightning protocols, laying the foundation for scalability and privacy.
RGB uses Single-Use Seals defined on Bitcoin UTXOs, enabling any party holding the contract state history to verify its uniqueness. In essence, RGB leverages Bitcoin scripts to define its security model, ownership, and access rights.
An RGB smart contract is represented as a Directed Acyclic Graph (DAG) of state transitions, where contracts are fully isolated. Only the contract owner—or parties to whom information has been disclosed—are aware of its existence.
|
A Directed Acyclic Graph (DAG) is a special graph structure useful for modeling complex systems. Imagine each edge in a DAG as a one-way street ("directed"), and assume no route allows you to return to your starting point ("acyclic"). Similarly, in a DAG, there is no sequence of edges that forms a cycle back to the original node. Applied to RGB, each contract can be seen as a node in the graph, and relationships such as ownership transfers form directed edges. This ensures clear, ordered, and non-circular dependencies between contracts—no contract can directly or indirectly affect itself. |
This architecture ensures that state commitments are unique and tamper-proof, preventing double-spending and guaranteeing consistency and validity in state transitions.

Diving into RGB Contracts
After understanding the architectural philosophy of RGB, let’s examine how contracts work. In conventional smart contract ecosystems, creators must either develop or commission custom code execution logic—a process prone to vulnerabilities and exploits. RGB aims to reduce coding risks and audit burdens by introducing the concept of "Schemas"—predefined templates for smart contracts. Issuers can use Schemas as reusable "contract blueprints," eliminating the need to write or audit bespoke code from third-party developers.
Flexible Scalability and Strong Interoperability
RGB contracts are defined in a declarative manner rather than imperative programming. Instead of specifying a sequence of commands, contract logic is described through rules governing behavior and state transitions—forming a state transition DAG. The key innovation lies in local state operations. Each node (or state) follows its own rules and manages only its local state transitions. This contrasts with global-state platforms like Ethereum, where every state change adheres to a single consensus algorithm. This localized approach grants RGB superior flexibility, scalability, and interoperability.
Simplified Smart Contract Development
Schemas define permissible types of global and owned states, seals, and metadata within state transitions. RGB uses the Contractum language to write Schemas and AluVM (Arithmetic Logic Unit Virtual Machine) to simplify smart contract creation. AluVM is register-based and disallows random memory access, making it ideal for smart contracts, remote code execution, and distributed and edge computing applications—providing a foundation for advanced use cases.
How RGB Ensures Security and Privacy
From RGB’s Own Design Perspective
- Privacy via Non-Global Broadcasting: As mentioned earlier, client-side validation means verification occurs only between directly involved peers—not across the entire network. This non-global broadcast model enhances privacy and censorship resistance, as contract details remain invisible to miners and external observers.
- Data Privacy via Sandbox Environment: RGB stores all operational data locally in a "stash." Since it is not blockchain-based, data isn’t replicated across peer nodes. Local user-controlled storage reduces exposure to external attacks and data leaks. Each program (“smart contract”) runs in an isolated sandbox environment, offering better scalability and security than blockchain-based platforms.
- However, off-chain data storage also introduces risk of data loss if backups are inadequate.
- Invoicing System Enhances Security and Privacy: Contract operations in RGB are initiated via invoices, which may contain multiple operation requests. By requiring users to explicitly specify and validate actions, the invoicing system improves accuracy and security. It also enables private transfer of operation requests between users, enhancing transaction privacy. State transitions like token transfers are executed via specific invoice-driven commands.
From the Perspective of Interaction with Bitcoin
- RGB is tightly coupled with the UTXO model. During interaction with Bitcoin’s mainnet, users create off-chain contracts to issue RGB assets linked to specific Bitcoin UTXOs—similar to how Lightning Network channels operate. Subsequent asset transfers, contract interactions, and validations occur off-chain using the mechanisms described above.
- RGB benefits indirectly from Schnorr signatures’ improvements in multisig, adaptor signatures, and Point Time-Locked Contracts (PTLCs). However, these benefits stem entirely from Bitcoin’s own upgrades. Internally, RGB does not require signing operations (so Schnorr brings no internal changes) nor does it use Bitcoin script (making Tapscript irrelevant).
BTC Security Lab, jointly initiated by ScaleBit, is a dedicated research laboratory focused on advancing RGB protocol security. Its mission is to safeguard smart contracts, contribute to ongoing protocol improvements, and strengthen Bitcoin’s infrastructure ecosystem.
Overview of RGB Ecosystem Projects
1. BiHelix
Website: https://www.bihelix.net/
BiHelix is a Bitcoin-native ecosystem infrastructure leveraging RGB and the Lightning Network to optimize node performance. It aims to make Bitcoin more accessible to developers, expand use cases, and overcome challenges related to scalability and Turing incompleteness. BiHelix seeks to build a fairer decentralized world for miners, validators, node providers, exchanges, and users. As the first infrastructure built on RGB, it aims to enable next-generation large-scale Bitcoin applications. Currently in R&D phase with no public interaction yet—stay tuned.
Key Features
- Low User Barrier: Uses SLR (Security-Lightning-RGB) protocol to repackage RGB and Lightning integration, introducing innovative lightning node solutions for universal global payments.
- High Reliability and Scalability: Built on mature cloud architecture, utilizing rust-lightning features to support channel factories for efficient channel management and batch creation.
- Security and Privacy Protection: Off-chain transmission and storage of state data, combined with recursive zero-knowledge proofs, randomize multi-hop payments and path selection to ensure privacy.
- Developer-Friendly: Offers comprehensive development tools including open-source documentation and SDKs. Introduces Schema-based social consensus to simplify dApp development.
2. Iris Wallet
Website: Link
Iris Wallet is the first Android wallet developed by the Bitfinex team, focused on RGB integration and tooling. It supports both fungible and non-fungible assets and enables full lifecycle operations—from issuance to spending and receiving—all within a familiar wallet interface while abstracting technical complexity. Currently experimental—recommended only for small amounts and low-value assets.
3. DIBA
Website: https://diba.io/
DIBA is the first NFT marketplace on Bitcoin using RGB Protocol, the Lightning Network, and smart contracts. It aims to redefine perceptions of self-custodied digital art on Bitcoin’s blockchain.
4. Bitmask
Website: https://bitmask.app/
Created by DIBA, Bitmask is the first NFT wallet in the RGB ecosystem. It runs in web browsers and interacts with RGB contracts similarly to MetaMask on Ethereum. Undergoing frequent updates, awaiting the V0.11 release.
5. Pandora Prime Inc
Website: https://pandoraprime.ch/
Pandora Prime is a Swiss company based in Verify Valley and a founding member of LNP/BP.
It focuses on pioneering Bitcoin Finance (BitcoinFi) by combining RGB smart contracts with the Lightning Network. Starting with programmable assets on Bitcoin (RGBTC and CHFN), it aims to scale transaction throughput to Visa/Mastercard levels via the Lightning Network while providing seamless asset exchange facilities. Current products include MyCitadel (wallet), RGB Explorer (block explorer), and Pandora Network.
6. MyCitadel
Website: https://mycitadel.io/
MyCitadel is a brand under Pandora Prime and the first GUI wallet supporting RGB, created in 2021 by RGB developers. Available as a cross-platform desktop wallet and iOS/iPad app, its mobile version handles fungible RGB assets.
7. RGB Explorer
Website: https://rgbex.io/
Developed by Pandora Prime, RGB Explorer is the first browser offering registration and exploration of RGB assets and smart contracts. Currently supports RGB20, RGB21, and RGB25 standards, displaying assets including LNPBP, RGBTC, dCHF, and RGBEX.
8. Bitlight Labs (formerly Cosminmart)
Website: https://bitlightlabs.com/
Bitlight Labs develops RGB-based infrastructure and plans to deploy multiple applications on the Lightning Network, including the Bitlight Wallet and Bitswap—an automated market maker for BitcoinFi built on Lightning and RGB protocols.
10. RGB Memes & NFT
10.1 PPRGB
X: @PepeRgb20
PPRGB is currently issued on the Liquid Network and will be mapped to RGB after the V0.11 release (which also includes Liquid integration features).
10.2 MRGB Inscriptions
MRGB Inscriptions are tokens operating on Bitcoin’s second and third layers (off-chain), powered by RGB’s client-side state validation and smart contract system. The protocol provides open-source底层code, allowing all BRC20 chains to integrate directly.
This innovation unlocks major potential for BRC20 chains—including reduced gas consumption, faster transactions, and improved overall performance. By adopting MRGB, BRC20 chains can process transactions more efficiently and lower user costs. Additionally, MRGB tokens serve as consumables during transactions, increasing BTC liquidity and scalability.
10.3 Single-Use-Seal
"Seal" refers to a 10K PFP collection, rare UDAs, and tokens on RGB20 and RGB21, named after Peter Todd’s Single-Use Seal concept. Currently awaiting Bitlight and Bitmask wallet updates to V0.11 before issuance.
10.4 Bitman
X: @bitmancity
Will launch a 10K UDA collection on DIBA, likely via whitelist + public sale, aiming to “carry forward the spirit of BTC.” The project plans to distribute WL spots to contributors in the BTC ecosystem, with most proceeds from public sales donated to LNP/BP.
BitVM
Why BitVM?
BitVM (Bitcoin Virtual Machine) introduces a system capable of verifying any computation on the Bitcoin blockchain without compromising security or altering network consensus. This breakthrough opens the door to complex computations—including Turing-complete smart contracts—with all processing handled off-chain to reduce congestion on Bitcoin’s base layer.
“In short, BitVM is a computational model that expresses Turing-complete contracts on the Bitcoin network.” Like RGB, BitVM requires no changes to Bitcoin’s consensus rules.
On October 9, 2023, Robin Linus, co-founder of blockchain development firm ZeroSync, published the BitVM whitepaper. Compared to RGB, BitVM is much newer.
BitVM Architecture
Architecture Overview
Similar to Optimistic Rollups and the MATT proposal (“Merkelize All The Things”), BitVM relies on fraud proofs and challenge-response protocols without modifying Bitcoin’s consensus rules. BitVM demonstrates that Bitcoin is Turing-complete when encoding large Taptrees for fraud proofs.
Gate Circuit Design
The Bit Value Commitment is the fundamental building block, allowing a committer to set a bit value to “0” or “1”. Any computable function can be expressed as a Boolean circuit composed of logical gate commitments. Using NAND gates (universal logic gates), each with its own commitment, arbitrary circuits can be constructed. Each execution step is committed within a Tapleaf and grouped under the same Taproot address.
BitVM leverages Bitcoin’s Taproot upgrade by creating a binary-circuit-like structure called a taptree. Within this system, spending conditions for each UTXO are represented by Script instructions, forming basic program units. These instructions generate binary outputs (0 or 1) within a Taproot address, collectively forming the entire taptree. The output of the taptree resembles the result of a binary circuit—effectively an executable program. The complexity of programs BitVM can execute depends on the number and complexity of underlying Taproot addresses. In essence, BitVM transforms Bitcoin’s Script instructions into binary operations, enabling more complex program execution on Bitcoin.

Two-Party Model
The current model is limited to two participants and cannot scale to more. Additionally, BitVM requires extensive pre-signing (off-chain computation), making it highly complex and potentially inefficient in practice.
Fraud Proofs and Challenge-Response Protocol
The prover and challenger deposit equal amounts of BTC into a transaction (as inputs), whose output contains a logic circuit. A series of pre-signed transactions set up during setup enable rebuttals to false claims. BitVM is often compared to Optimistic Rollups because it executes most computation off-chain and only submits some computations on-chain in case of disputes.
- Optimistic rollups are Layer 2 scaling solutions that reduce base-layer load by moving computation and data storage off-chain, then bundling and posting multiple transactions to the main chain.
- They assume all transactions are valid. If a participant detects dishonesty, they can submit a fraud proof—an evidence of incorrect computation generated upon verification.

Off-Chain Computation
Almost all activity in BitVM occurs off-chain, including initiating tasks, sharing data, and validating claims. Computation is generally not performed on the Bitcoin blockchain. Only in the event of a dispute due to suspected fraud are certain computations posted on-chain. Even then, only a minimal portion of the disputed process runs on-chain—just enough to identify the dishonest party.
With this background, we can now better understand the detailed mechanics of BitVM’s two-party interaction.
The two-party model involves a Prover and a Verifier. The Prover first creates and submits a smart contract or program, then sends funds to a jointly controlled root address secured by a 2-of-2 multisig. The Prover must also share sufficient information with the Verifier to prove the program produces the claimed output.
The Verifier runs the Prover’s code and checks whether the output matches expectations. If not, the Verifier challenges the Prover. This challenge-response process uses off-chain data exchange and pre-signed transactions to verify computational correctness.
If an error is found, the Verifier can publish a fraud proof on-chain to expose the Prover’s dishonesty. In BitVM, if the Prover’s response is proven wrong, they lose their stake. Conversely, if all answers are correct, the Prover retains their funds. This economic incentive mechanism discourages dishonest behavior.
Ultimately, this interaction ensures that computation verification only moves on-chain when disputes arise, keeping the vast majority of processing off-chain. This design preserves Bitcoin’s efficiency while enabling more complex programs on Bitcoin.
BitVM Security
From an architectural standpoint, BitVM’s security rests on several pillars:
Fraud Proofs
In case of disputes, the Verifier can challenge false claims using fraud proofs. This mechanism mirrors Optimistic Rollups and requires no changes to Bitcoin’s consensus rules.
Challenge-Response Protocol
BitVM uses a challenge-response protocol where the Prover and Verifier pre-sign a series of transactions during setup. These are used to resolve disputes when they occur.
Off-Chain Computation with On-Chain Verification
BitVM enables complex off-chain computation, with only dispute resolution occurring on-chain. This minimizes on-chain resource usage while preserving Bitcoin’s integrity and security.
Deposit and Penalty Mechanism
If the Prover makes an incorrect claim, the Verifier can confiscate their deposit. This ensures attackers always lose funds when acting dishonestly.
Dual-party contract mechanism enhances privacy and reduces transaction costs but sacrifices generality compared to multi-party systems like EVM.
Nostr Protocol
What is Nostr?
Nostr stands for “Notes and Other Stuff Transmitted by Relays”—literally “notes and other content transmitted via relays.” From the full name, it’s clear this is a transmission protocol, and the presence of “relays” indicates it is not a P2P protocol. According to GitHub commit history ([link](https://github.com/nostr-protocol)), the project launched in November 2020. Nostr aims to create the simplest open protocol for a censorship-resistant global social network—a decentralized social protocol allowing users to create, publish, and subscribe to any content without control from centralized platforms or institutions. Inspired by Bitcoin and the Lightning Network, Nostr uses similar cryptography and consensus mechanisms, along with a data structure called the Nostr Network based on events.
Components of the Nostr Protocol
Public-Private Key Pair
A public-private key pair constitutes a Nostr account. Unlike traditional username/password systems, Nostr uses a cryptographic key system similar to cryptocurrencies. For simplicity, think of the public key as a username and the private key as a password. Note: losing the private key means permanent loss—there’s no recovery option. Public keys start with npub1; private keys with nsec1. Keys must be securely stored, as recovery is impossible once lost.
Clients
Nostr itself is just a protocol for sending messages over the internet. Users need client software to interact with it—available as web apps, desktop apps, or mobile apps. Clients read data from relays and send new data to relays for others to retrieve. Data includes signatures ensuring authenticity, generated using the user’s private key. When setting up a desktop or mobile client, the private key must be stored locally (from which the public key is derived). For web clients, it’s not recommended to store the private key directly—better to use browser extensions.
Relays
Relays act as backend servers for the Nostr protocol. Clients send messages to relays, which may store and broadcast them to connected clients. Relays are not static—they frequently change. Nostr relies on relays for data storage and retrieval. If a client feels slow, it might be due to poor relay performance—users can improve speed by adding more reliable relays.
NIPs
Nostr Implementation Possibilities (NIPs) standardize compatible relays and client software—defining what must, should, or may be implemented. NIPs are reference documents explaining how the Nostr protocol works. As a decentralized protocol not controlled by any central entity (like Twitter), Nostr’s evolution depends on community input. Anyone can propose changes and provide feedback. Active members influence the future direction of the Nostr network. Approved NIPs reside in the main repository, and new ideas can be submitted via pull request.
Key NIPs include:
- NIP-04: Message Encryption using secp256k1 for Diffie-Hellman key exchange and end-to-end encryption
- NIP-05: Map Public Keys to Domains for easier recall (e.g., mapping a long npub key to @NomandJames)
- NIP-06: Mnemonic Phrases, similar to crypto wallet seed phrases
- NIP-13: Proof of Work. Concept predates Bitcoin, widely used in blockchain POW consensus and Ethereum’s Whisper protocol. Requires clients to complete a compute-intensive PoW before sending messages; relays validate the proof, raising the cost of spamming relays.
- NIP-22: Event Timestamps. Tells relays when a message was created, allowing selective acceptance. Timestamps can be set in the past or future.
- NIP-40: Expiration Time. Informs relays when a message expires, so they can delete it.
- NIP-57: Lightning Network Zap Links.
- NIP-65: Recommended Relay List.
Events
Events are the sole `Object` type in Nostr. Each event has a `kind` field indicating its type—what action was taken or information received.
How Nostr Works
Nostr operates through relays, which allow users on the same relay to exchange JSON files.
Below is a simplified illustration:
The diagram includes 3 relays and 3 users (clients), each using different client software (on different platforms).
Read/write relationships:
- Bob sees all of Alice’s posts but none of Mary’s (Bob doesn’t even know Mary exists).
- Alice sees Bob’s posts but not Mary’s (Alice is unaware of Mary).
- Mary sees both Bob’s and Alice’s posts. Since Mary only writes to Relay 3, she reads Bob and Alice’s data from Relay 2.

Deep Dive: Nostr Contracts
Given Nostr’s lightweight nature as an open protocol for decentralized social media, here’s a brief code-level analysis:
At its core, Nostr relies on a WebSocket server (called nostr-relay) handling a simple data structure known as an Event:
{
"id": <32-byte sha256 hash of serialized event data>,
"pubkey": <32-byte hex-encoded public key of event creator>,
"created_at": <unix timestamp in seconds>,
"kind": <integer>,
"tags": [
["e", <32-byte hex ID of another event>, <recommended relay URL>],
["p", <32-byte hex key>, <recommended relay URL>],
... // other tags
],
"content": <arbitrary string>,
"sig": <64-byte Schnorr signature of the event hash (same as "id")>
}
Events are always signed (using Schnorr-type signatures) and contain structured data with semantic meaning. XOnlyPubkeys (defined in BIP340)—used in Bitcoin Taproot—are employed throughout the protocol as identities.
A nostr-client is an app that communicates with nostr-relays and subscribes to event sets using filters.
Filters represent the set of Nostr events a client is interested in.
Clients don’t need registration—identity comes from the public key. Every time a client connects to a relay, it submits subscription filters, and the relay streams matching events as long as the connection lasts.
Relays can cache subscriptions but aren’t required to. Clients should handle everything locally, while relays can be as simple as possible.
Clients do not communicate directly. But relays can. This allows relays to fetch data they don’t have, and clients can subscribe to events beyond their direct relays.
At first glance, Nostr may seem useless (“why not just sign raw JSON and let clients figure it out?”), but deeper inspection reveals powerful engineering advantages in the “dumb server, smart client” model for decentralized protocol design.
Full Decentralization as Nostr’s Core Feature
As a protocol layer for social applications, Nostr transmits notes and content via relays without relying on centralized servers. Its full decentralization allows any app to freely integrate, providing an open, permissionless social platform via a distributed network. Thus, Nostr does not offer end-user C-side products—it focuses solely on building essential infrastructure at the protocol level. Productization is left to third-party apps, and users across different apps retain interoperable social experiences.
Nostr’s advantage lies in offering a truly free and open social network—immune to centralized power or interests. Users can express views and beliefs freely without fear of censorship, bans, or deplatforming. Content creators can set their own monetization models without income deprivation or unfair competition. Users can choose their social circles freely, avoiding manipulation, misinformation, or privacy violations.
Compared to traditional social media, Nostr offers several distinct features and advantages:
Decentralization
Nostr doesn’t depend on centralized servers or platforms. Information is transmitted and stored via a peer-to-peer network. Users don’t need to worry about data theft, censorship, or deletion, nor are they bound by third-party rules or policies.
Autonomy
Nostr gives users full control over their data and identity. They can freely choose who to follow and trust, and express opinions without fear of being banned, shadow-banned, or downgraded. Free from ads and algorithmic interference. Authentic verification helps identify spam and bot accounts easily.
Openness
Nostr is an open protocol—anyone can participate and contribute. Users can develop and use various clients, run their own nodes (servers that forward and store Nostr data), and create custom types and tags—metadata for classifying content. The simple and flexible Event format supports diverse publishing: social posts, long-form content, rich media, e-commerce, etc. Integrated with the Lightning Network, Nostr enables new [value-for-value] and fairer business models.
Nostr Protocol Security Risks
Private Key Management
Nostr uses public-private key pairs as accounts, requiring users to manage private keys independently. Loss of the private key means permanent loss of access. This poses a challenge for average users lacking technical expertise in secure key management.
Users must manually select and verify relays. Choosing an untrusted or malicious relay risks data leakage, tampering, or deletion.
Information Propagation
Messages sent via Nostr do not automatically propagate across multiple relays. If insufficient relays receive and store a message, it may be lost or unseen by others.
Increased Silo Effect
Relays can freely decide which messages to accept and store. This could lead to some relays prioritizing only content they deem valuable or aligned with their interests, ignoring or rejecting others—creating information silos.
Malicious Protocol Extensions
While Nostr defines basic event types and functions, it allows optional implementation of additional features by clients and relays. This could result in insecure or malicious functionalities being introduced, compromising user safety and privacy.
Data Handling Issues
Due to the lack of a consensus layer, some relays do not validate timestamps significantly deviating from UNIX time, leaving room for clients to forge messages using time discrepancies.
Nostr Ecosystem Overview
Nostr’s primary supporter is Jack Dorsey, co-founder of Twitter. As early as December 2022, Dorsey donated 14.17 BTC (worth ~$245,000) to support Nostr’s development. His personal Nostr address remains prominently displayed on his X profile, underscoring his strong endorsement.

Damus⚡️: Main Application of Nostr
X: https://twitter.com/damusapp


Damus is a social app supporting Bitcoin tipping via the Lightning Network, replacing common “Like” buttons with monetary tips. The low fees of Lightning make micro-tipping practically cost-free.
Beyond Damus, other Nostr applications include messaging tool Anigma, text-sharing tool Sendtr, and online chess game Jeste.
TGFB: Major Media Partner of Nostr
Website: https://tgfb.com/
TGFB is a Christian Bitcoin education platform aiming to equip believers to understand Bitcoin and use it to glorify God and benefit humanity.
A significant portion of its content covers Nostr protocol discussions—hosted by Jon and Jordan—from a Christian perspective, exploring the implications of this decentralized social protocol. Given Christianity’s global reach, combined with widespread U.S. awareness of Bitcoin (including SEC-approved ETFs) and the massive user base of the Lightning Network, the convergence of these three forces is driving strong adoption and advocacy for Nostr—greatly accelerating its ecosystem growth.
Nostr Derivative Protocols
Nostr + Taproot Assets
Nostr Assets Protocol is an open-source protocol bringing Taproot Assets and native Bitcoin payments (in Satoshis) into the Nostr ecosystem. It also supports interoperability with other payment protocols like Lightning Network and Taproot Assets.
Once assets are introduced, users can send and receive them using Nostr’s public and private keys at the protocol layer. Settlement and security still rely on the Lightning Network—Nostr Assets doesn’t issue assets but integrates them into the Nostr platform.
Nostr Assets builds on Nostr’s technology but is a separate protocol. It uses Nostr messages to control (custody) wallets, improving basic functions like transfers and trades.
Its full custodial service allows users to deposit Bitcoin or other assets into a wallet controlled by Nostr Assets Protocol, then issue instructions (e.g., deploy, mint, transfer) via Nostr messages.
However, full custody raises concerns: the protocol’s custodial wallet may pose security risks. Users lack full control—loss or theft due to hacks or exit scams could result in total asset loss.
Additionally, after launching on October 30, high deposit volumes led to repeated site maintenance outages, raising questions about the team’s credibility and project reliability. On November 8, the official Nostr Assets account replied in Chinese to a tweet, further fueling doubts about the team’s legitimacy. Meanwhile, the official Nostr team strongly opposes the namesake token associated with this extension protocol.
Nostr + Inscription
Noscription is an experimental token protocol on Nostr, allowing users to create and trade BRC-20-like tokens—distinct from Taproot Assets-style tokens.
Comparison Among the Three
Protocol Adoption
BitVM demands extremely high computational resources and remains largely theoretical. RGB leads in practical deployment with numerous live applications (though slowed by limited, non-profit developers at LNP/BP). Nostr faces similar bottlenecks as typical SocialFi projects, limiting broader protocol adoption.
Privacy Protection
Both RGB and BitVM perform off-chain computation. However, RGB ensures third parties cannot track asset histories on-chain—only recipients learn asset provenance. BitVM lacks this feature. Nostr, as a social protocol, faces privacy risks due to unpredictable relay behavior—potential for data leaks, censorship, loss, or malicious tampering.
BTC Native Compatibility
Neither RGB nor BitVM requires Bitcoin protocol modifications. Nostr is built natively on the Lightning Network. All three maintain strong Bitcoin-native compatibility and smooth developer experience.
Protocol Security
RGB executes off-chain, with sandbox isolation ensuring data security. The invoice system further strengthens data integrity. At the Bitcoin interaction level, it uses a Lightning-like model for asset issuance.
BitVM adopts a Rollup-like model with off-chain execution. The VM architecture, combined with fraud proofs and challenge-response mechanisms, ensures security.
Nostr uses a relay-based model, where clever inter-relay communication design and cryptographic algorithms ensure message security.
Within the Web3 industry, there has been no dedicated lab focused on Bitcoin ecosystem security. The establishment of BTC Security Lab fills this gap, providing professional security research and support. ScaleBit and BiHelix aim to lead the Bitcoin security space, setting industry standards and promoting healthy ecosystem development.
Ecosystem and Commercialization
As a social protocol, Nostr surpasses BitVM and RGB in user base and traffic momentum, with relatively more mature ecosystem expansion and commercial applications.
RGB has been around longer and hosts numerous ecosystem projects, many of which are currently awaiting the V0.11 release.
BitVM’s whitepaper was released only months ago, and its ecosystem is still nascent.
All three protocols are expected to give rise to numerous DApps in SocialFi, GameFi, and DeFi, sparking renewed interest in the Bitcoin ecosystem.
Special thanks to Ausdin.eth, 0xLayman, Echo, and Venus for their contributions to this report.
*Disclaimer: Markets involve risk. Invest responsibly. This article does not constitute investment advice. Readers should consider whether any opinion, view, or conclusion herein suits their individual circumstances. Investment decisions based on this information are at the reader’s own risk.*















