Tether's USDT went live on the Lightning Network on March 21, 2026. Not one routing node had to upgrade to carry it. The dollars exist at two points on the route and nowhere else in between, and the trick that makes that work is sixty years old.
Stablecoins work on Lightning by never traveling as stablecoins. A dollar token is issued on Bitcoin's base layer with the Taproot Assets protocol, then deposited into a Lightning channel between the holder and an edge node. To pay, that edge node converts the dollars to bitcoin at a signed, time-limited price quote, the payment crosses the network as an ordinary bitcoin HTLC, and a second edge node converts it back at the far end. Only the first and last hops ever know an asset was involved. Tether confirmed USDT was live on Lightning this way on March 21, 2026, completing a 14-month integration with Lightning Labs. Section 04 runs a real payment through a route; section 06 covers why the alternative design is so much harder to bootstrap.
If a dollar token lives on Bitcoin's blockchain, which part of the blockchain is the dollar?
None of it. Search every block ever mined and you will not find the word USD, an amount, or a token balance. Taproot Assets does not put the asset on the chain. It puts a commitment to the asset on the chain: a single 32-byte number, tucked into a Taproot output, that looks exactly like every other Taproot output.
The asset itself, the amount, the issuer, the ownership history, all of it lives off-chain in files held by the people involved. The chain's only job is to stop the same coin being spent twice. This is called client-side validation, and Taproot Assets and RGB both use it.
Move the slider from $1 to $1,000,000. Every bit of the output key changes, and at no point does it look like anything but a random public key. That is the point: a $10 mint and a $10,000,000 mint are indistinguishable to anyone watching the chain.
The elliptic-curve tweak above is real, computed live on secp256k1 in your browser. The serialization is simplified for readability, so the digest is not byte-identical to what tapd would produce for the same mint, but the structure and the privacy property are the genuine ones.
Lightning channels hold bitcoin. What does it even mean to put a dollar in one?
A Taproot Assets channel is funded with both. There are sats in it, and there is an asset balance committed alongside them. When a payment moves through, it creates a normal Lightning HTLC in bitcoin, with the asset transfer nested inside it. Lightning Labs describes these as nested HTLCs: the same preimage, the same timeout, the same penalty mechanics that already secure bitcoin channels.
The sats are not the value. They are the vessel. Every HTLC output needs enough bitcoin to be economically spendable on-chain if the channel ever closes badly, and that requirement does not grow with the dollar amount riding on top.
Anchoring is modeled at the 330-sat Taproot dust limit per in-flight HTLC, and 483 is lnd's default maximum concurrent HTLCs per channel. Real channels also hold working bitcoin liquidity beyond the anchors; this widget isolates the anchoring floor to make the point about scale.
Push the dollar slider to a million. The bitcoin required to carry it does not move. A channel's asset capacity is bookkeeping; its sat requirement is a function of how many payments are in flight at once, not how much they are worth.
You hold the key. The UTXO is confirmed. Why might the dollars still be gone?
Because with client-side validation, ownership is a file. Every transfer of a Taproot Asset produces a proof that links back to the previous one, all the way to the genesis mint. To spend, you hand the next owner that chain of proofs and they verify it themselves. No proof, no provenance. No provenance, no spend.
This is the part that surprises people who are used to normal Bitcoin. Your seed phrase recovers your bitcoin. It does not recover your assets, because the proofs were never derivable from it. Lightning Labs' own operational safety documentation is blunt about this: there is no mechanism to recover assets from the lnd seed alone, and the warning shipped with Lightning Terminal on Umbrel still reads, in capitals, that without a backup before deletion, funds are destroyed.
Each proof is a real SHA-256 digest committing to the previous proof and the transfer beneath it. Delete any one and verification stops there, because nothing downstream can be linked back to the mint.
Notice what did not change when you deleted a proof: the bitcoin. The UTXO is still there, still confirmed, still yours. What vanished is the ability to prove which dollars it represents. In a system where the ledger is a stack of files, backing up the files is not housekeeping. It is custody.
You are paying a merchant in dollars, five hops away, who has never heard of Taproot Assets. What crosses the wire?
Sats. Only sats. Before the payment starts, your edge node gives you a Request for Quote: a signed, time-limited exchange rate between your asset and bitcoin. That rate is baked into an ordinary BOLT 11 invoice, indistinguishable from any other. Your dollars are converted at hop one, the bitcoin travels, and if the recipient wants dollars, their own edge node converts back at the far end.
Set the amount and the spread, then switch between the three views. The fee arithmetic below is the real Lightning fee accumulation, computed backwards from the destination the way a sender actually builds a route.
Bitcoin priced at $118,000 for this demo. Routing fees use base + amount × ppm accumulated backwards from the destination; the spread is applied once at each edge node. Real spreads vary by asset, size and node, and a real route may have a different number of hops.
Three of the five hops never learn the asset exists. They see an incoming HTLC in millisatoshis, a payment hash, a timeout and an onion packet for the next hop. That is the entire mechanism. Stablecoins reached Lightning not by teaching the network about dollars, but by refusing to.
How do you send something a network was never built to carry, when you cannot change the network?
In 1962 AT&T introduced the Bell 103 dataset. The telephone system moved one thing: the sound of a human voice. It had no concept of a byte, and AT&T's tariff forbade attaching foreign equipment to the line at all. So the modem did not ask the network for anything. It turned bits into two audible tones, 1,070 Hz and 1,270 Hz, at 300 bits per second, and turned them back into bits at the other end.
Every switch, every relay, every operator in between carried what it thought was a phone call. The meaning existed only at the two ends. Modulate at one edge, demodulate at the other, and a voice network becomes a data network without a single upgrade in the middle.
This is a genuine continuous-phase FSK modulator and quadrature demodulator running on your text, at the Bell 103 originate frequencies and 300 baud. Sampling is at 9,600 Hz so each bit is exactly 32 samples; a real 103 modem worked on an analog voice line with no fixed sample rate. Push the noise slider and watch the recovered text degrade, then break.
The modem makers did not win on merit alone. Thomas Carter of Texas had sold about 3,500 units of a device that patched a two-way radio into a phone handset, and AT&T's tariff meant using one could get your service cut off. On June 26, 1968, the FCC ruled those restrictions unlawful. Datamation's headline that August read that the decision unsettled the carriers and encouraged the modem makers.
Nineteen years later, Saltzer, Reed and Clark gave the idea its name. Their paper "End-to-End Arguments in System Design," published in ACM Transactions on Computer Systems in November 1984, argued that functions belong at the edges of a network, not in its middle, because the middle can never know enough about the application to do the job properly.
The comparison holds where it matters and breaks where you would expect. A modem's tones are self-describing; a payment's exchange rate is not, so the rate has to be negotiated and signed in advance. That negotiation is the RFQ, and it is where the real work sits.
It sounds simpler to move the asset end to end. Why convert twice instead?
Because a network where the asset travels is a network you have to build again for every asset. If a dollar payment must cross channels that all hold dollars, then dollars need their own connected graph, their own liquidity, their own routing nodes. So do euros. So does every token after them. Payment networks have always had this bootstrapping problem, and it is the reason most new assets never get a payment network at all.
The edge model sidesteps it. Bitcoin is the routing currency, the graph already exists, and a new asset only has to find two willing counterparties rather than a whole path of them. Below, adoption means the share of nodes that support your specific asset.
A deliberately simple independence model: each node supports the asset with probability p, drawn independently. Real Lightning routing is nothing like random, and both models improve with multi-path payments, so treat the ratio as illustrating a shape, not forecasting a success rate. The bars are empirical counts from the trials, not the closed-form probability.
This is the honest version of the Taproot Assets versus RGB comparison, and it is narrower than the slogans on both sides. Both protocols issue assets on Bitcoin with client-side validation. They differ in what crosses the network. RGB's Lightning design routes the asset itself, adding an RGB anchor to each commitment transaction, which is elegant and gives every hop full asset awareness. The cost is that the hops have to be asset-aware. RGB's own maintainers have long acknowledged this pushes toward asset-specific sub-networks, and have proposed exchange nodes that convert to bitcoin at the boundary, which converges on the same answer from the other direction.
The maturity gap is real and worth stating plainly. RGB reached mainnet with v0.11.1 in July 2025 and Tether announced plans for USDT on RGB in August 2025. But the RGB Lightning Node repository still describes itself as early alpha and testable only on regtest and testnet. Taproot Assets shipped multi-asset Lightning on mainnet with v0.6 in June 2025, reached v0.8 in June 2026, and is carrying live USDT today. That is a statement about where each project is in 2026, not about which design is better in 2030.
If your dollars become bitcoin at hop one, who owned the bitcoin they became?
An edge node. The whole design rests on there being nodes that hold inventory in both assets and are willing to quote a price between them. Lightning Labs calls the result a decentralized foreign exchange network, and the phrase is more literal than it sounds: edge nodes compete on spread the way FX desks do, and they carry the same risks. Inventory on both sides. Rate movement between quote and settlement. Quotes that expire before a slow route completes.
This is the layer Amboss builds. Rails, launched in May 2025, lets liquidity providers earn on self-custodied bitcoin by serving channel leases and routing. Because Rails supports Taproot Asset deposits, the same providers can hold asset inventory and quote cross-asset payments, which is what turns a bitcoin routing node into an edge node. RailsX, announced at the Plan B Forum in January 2026 and live for early users on April 28, 2026, adds peer-to-peer trading on top, launching with USDT-L and USDC-L issued by Speed Wallet and settling atomically over Lightning channels rather than through a custodian.
What that stack buys Amboss Payments is a stablecoin product with no new chain and no custodian in the middle. The dollars are Taproot Assets on Bitcoin. The route is the Lightning Network that already exists. The conversion happens at nodes that never take possession of the counterparty's funds, because the swap is atomic.
| Risk | Where it lands | Status |
|---|---|---|
| Issuer trust | Self-custody of a token is not self-custody of the dollar behind it. The redemption claim is still on the issuer. | unchanged |
| Proof backup | Losing the tapd database loses the assets. The lnd seed does not recover them. | improving |
| Quote expiry | A signed rate has a deadline. A slow or failing route can strand a payment against a stale quote. | improving |
| Edge liquidity depth | Large payments need deep two-sided inventory. v0.6 let receivers combine up to 20 inbound asset channels; v0.7 added multi-quote sends. | improving |
| Non-fungible assets | An indivisible asset cannot be split across an HTLC, so NFT-style Taproot Assets do not route over Lightning at all. | by design |
Version numbers and dates from Lightning Labs release announcements for tapd v0.6 (June 2025), v0.7 (December 2025) and v0.8 (June 2026).
The blockchain never sees your balance. Taproot Assets commits to a 32-byte value in a Taproot output. The amount, the ticker and the history live in files held off-chain, which is why a $10 mint and a $10,000,000 mint look identical to a chain analyst.
Back up the proofs, not just the seed. Your lnd seed phrase recovers bitcoin. It does not recover Taproot Assets. Read Lightning Labs' operational safety guidelines before putting real value on a node, especially on a node-in-a-box where uninstalling an app deletes its data.
The middle of the network is deliberately ignorant. Three of five hops on a typical asset payment forward plain bitcoin. That ignorance is the feature: it is why USDT could go live on Lightning in March 2026 without a network-wide upgrade, and why the next asset will not need one either.
Self-custody of the token is not self-custody of the dollar. Taproot Assets removes the custodian from the payment. It does not remove the issuer from the redemption. Those are different questions and any honest pitch keeps them separate.
A dollar token is issued on Bitcoin's base layer using the Taproot Assets protocol, then deposited into a Lightning channel between the holder and an edge node. To pay, the edge node converts the dollars into bitcoin at a signed, time-limited price quote, the payment crosses the network as an ordinary bitcoin HTLC, and a second edge node converts it back at the far end. Only the first and last hops are aware an asset was involved.
No. Only the two edge nodes at either end of the route need to run Taproot Assets software. Every intermediate node forwards a normal bitcoin HTLC and never learns which asset, if any, was involved. This is why stablecoins on Lightning did not require a network-wide upgrade.
Yes. Tether CEO Paolo Ardoino confirmed USDT was live on Bitcoin and Lightning via Taproot Assets on March 21, 2026, completing a 14-month integration announced with Lightning Labs at the Plan B Forum in El Salvador on January 30, 2025.
Both issue assets on Bitcoin using client-side validation. The routing model differs: Taproot Assets converts to bitcoin at the edges so the existing Lightning graph carries the payment, while RGB channels route the asset itself, which requires asset-aware channels along the path unless gateway nodes convert. RGB reached mainnet with v0.11.1 in July 2025, and its Lightning node implementation is still labeled early alpha by its own maintainers.
The token is held in your own channel with your own keys, so custody of the token is yours. The dollar backing it remains a claim on the issuer, which is a separate trust assumption. There is also an operational catch: the tapd proof database is custody material, and Lightning Labs' own documentation warns that an lnd seed phrase alone is not enough to restore assets if that database is lost.