ONE 2-OF-2 OUTPUT, TWO VERSIONS OF WHO OWES WHAT
Bitcoin’s base layer was never designed to carry small payments, and Lightning is the structure people built on top of it to fix that — but Lightning is not a token, not a custodian, and not a company promise. It is a pile of real Bitcoin UTXOs plus a stack of transactions that both sides have already signed and neither side wants to broadcast, and its safety comes from the fact that either party can leave at any moment while the party who lies loses the entire channel.
The claim, stated so it can be attacked
There is no mechanism on Bitcoin that makes a small payment cheap enough to stop caring about. That is true for a structural reason, not a temporary one: an on-chain payment is not a message between two people, it is an entry in a ledger that every full node has to store, validate and relay forever. What you are buying is permanent global storage, and that auction does not care whether you are moving a house or a cup of coffee.
I have watched people dodge this for years: fees will fall, batching will save us, some soft fork will fix it. None of that touches the unit economics. If you want cheap small payments, you have to stop making the world record every one of them. Everything else in this article follows from that sentence.
There is no custody here, and there is no coin
Let me say the load-bearing thing early, because most popular explanations get it wrong. There is no Lightning coin, there is no Lightning blockchain, and there is no moment where you hand your bitcoin to somebody who promises to give it back. What exists is:
- a normal Bitcoin transaction that creates a 2-of-2 multisig output, and
- a stack of transactions spending that output, already signed by both parties, sitting unused on two hard drives.
The system was described in February 2015 by Joseph Poon and Thaddeus Dryja in “The Bitcoin Lightning Network: Scalable Off-Chain Instant Payments,” and they were explicit that value transfer happens off-chain while remaining enforceable on-chain whether your counterparty cooperates or not. Part of the inspiration came from Satoshi’s 2008 description of high-frequency transactions. The machinery is standardised as BOLT (Basis of Lightning Technology), with four mainstream implementations: Lightning Network Daemon (lnd), CoreLightning, Eclair and Lightning Dev Kit.
funding output script = P2WSH to: 2 <pubkey_A> <pubkey_B> 2 OP_CHECKMULTISIG, with the two public keys sorted lexicographically
That single line is where custody dies. Once the funding transaction is confirmed, neither party can move the money alone. Not “the network will stop you,” not “an arbitrator will review it” — the script cannot be satisfied by one key. The same primitive is covered in Multisig, read from the source.
So the safety model is not “somebody is watching you.” It is: either party can walk away unilaterally at any second, and the party who cheats gets the whole channel swept by the other one. Trust has been replaced with an obligation to produce evidence in time.
Recorded by everyone versus signed by two people
Here is the first contrast, and it is the one that explains all the others. A chain transaction is public accounting: it is broadcast, it competes for block space, it is validated by thousands of strangers, and when it settles it has rewritten a shared reality. A channel payment is two people exchanging a new pair of receipts, each a fully valid Bitcoin transaction signed in advance and then quietly not broadcast.
The distinction is not “off-chain is faster.” It is who has to agree. For a chain payment, consensus has to agree; for a channel payment, only two people do, and the chain is held in reserve to settle the disagreement. That is why a channel balance can be denominated in millisatoshi, a unit the base layer does not have: the granularity is private, so making it finer costs nothing.

Not “faster settlement” but “settlement deferred, and that deferral is the product.” Once you see that, the time locks, the revocation keys and the requirement to stay online stop looking arbitrary — all of them exist because you have accepted a balance that is real between two people but not yet real to the world.
The two copies are deliberately unequal
Now the second contrast, the one I would make everyone learn before running a node. At any moment there are two commitment transactions describing the same channel, and they are not harmless mirror images — they are asymmetric on purpose.
In the copy you hold, your own output is encumbered by a relative time lock (OP_CHECKSEQUENCEVERIFY) of to_self_delay blocks, while your peer’s output is immediately spendable. In the copy your peer holds, the situation is reversed. BOLT 5 puts it without ceremony: if your node broadcasts its own commitment, it waits before touching its funds, and the remote node can spend immediately.
Why sign such a thing? Because unilateral exit has to be deliberately slower for whoever initiates it. If closing alone were instant and free, it would become the default and the point of keeping payments off-chain would collapse. The delay is not punishment for leaving; it is the dispute window in which the other party can prove you left dishonestly.
BOLT 5 defines the commitment transaction as a cross-signed transaction describing the current state of the channel, updated every time a new payment is made, and spendable at all times. Note the tension: it is spendable at all times and yet never broadcast. The right you hold is the right to end the channel on current terms without anyone’s permission, and that unexercised right is what secures the arrangement.
One wrinkle, because this is engineering and not scripture: the original paper imagined both sides funding the channel, the spec as of 2020 assumed a single funder, and dual-funded channels were still experimental in CoreLightning as of May 2021.
A payment is three messages, and a close is one transaction
The third contrast is between cooperative and forced, but it makes no sense until you see what a payment physically is. Per BOLT 2, a normal channel payment is three messages:
update_add_htlc— one side proposes the change,commitment_signed— the other side signs the new state,revoke_and_ack— the proposer hands over the key that invalidates the previous state.
That third message is where the security model lives, and the ordering is not negotiable: you give up the ability to broadcast the old state only after you hold a signature on the new one. There is no instant in which you are exposed.
- Openthe base layer must agree a funding transaction exists before any of the rest is possible.
- Fundafter enough confirmations the whole network knows a 2-of-2 output exists, while only two people know what it is for.
- Paya broadcast payment bids for block space against strangers, a channel payment swaps two signatures and nothing else.
- Updatethe public ledger rewrites a shared record, the channel rewrites a private balance denominated in millisatoshi.
- Disputeconsensus simply rejects an invalid chain transaction, whereas an old channel state is perfectly valid and has to be punished instead.
- Closeending together costs one transaction and no waiting, ending alone costs one transaction and a delay.
- Forcethe honest party waits out a timelock, the dishonest party waits to be swept.
- Finalitychain settlement deepens with every block, channel settlement ends when the timelock expires unchallenged.
- Memorythe chain remembers every payment forever, the channel forgets everything the moment both sides revoke.
Cooperative close is boring, and that is a compliment: both parties sign a final transaction splitting the funding output by the current balance, and since nobody is being punished, both outputs are immediately spendable. No time lock, no dispute window, one transaction, done.
Force close is what happens when boring fails. One side broadcasts its own commitment, and the asymmetry comes due: the broadcaster’s funds sit behind to_self_delay blocks while the other side’s are free at once. That waiting is the price of exit being unilateral, and you pay it because the alternative, needing permission to leave, is worse.

One cost detail bites people exactly once: the fee rate inside a commitment transaction was fixed on the day it was signed. If the fee market spikes before you broadcast, your exit can stall, which is why later work introduced anchor outputs and zero-fee commitments. I will not turn this into a tutorial; I mention it because “my exit transaction is too cheap to confirm” is a failure mode that no amount of ideological confidence fixes.
Cheating is legal; losing everything is the consequence
This is the fourth contrast, and the one most explanations soften past recognition. When you broadcast a revoked state, the protocol does not reject you. There is no consensus rule against it, no node that refuses to relay it, no referee. The old commitment transaction is valid Bitcoin and it confirms like any other.
What stops you is not validation, it is confiscation. Each time the state advances, the two parties exchange the private half of the revocation key from the state being retired; once you have handed it over, broadcasting that state lets your peer sweep the entire channel balance. The design is not “cheating is prevented,” it is “cheating is permitted and priced at one hundred percent of your money.”
OP_IF <revocation_pubkey> OP_ELSE <to_self_delay> OP_CHECKSEQUENCEVERIFY OP_DROP <local_delayed_pubkey> OP_ENDIF OP_CHECKSIG
Read that branch as a two-way door: if the revocation key is known, this output belongs to my peer; otherwise it belongs to me, but only after the delay. The punishment key is constructed jointly, the way a multisig is, so Alice cannot manufacture Bob’s half alone and punish herself by accident.
Cheating is irrational, so nobody cheats. I can close my laptop for a month and the arithmetic still defends my balance.
Irrational for whom, exactly? The arithmetic defends you only if somebody actually broadcasts a penalty transaction inside the dispute window.
Then I rent a watchtower: it watches the chain on my behalf, sweeps the cheater, and cannot itself take my funds.
It cannot take them, agreed. But now my safety depends on a third party that is online, honest enough, and paid.
Which is the honest version of the trade: trust was never eliminated, it was relocated from my counterparty to my own diligence.
The skeptic wins that exchange, and people should admit it more often. Watching the chain is a duty, and it can be outsourced to a watchtower: a paid third party that monitors for fraud and executes the penalty for you, trusted only to that extent. It is the most under-discussed part of Lightning.
Routing without trusting the middle
You do not need a direct channel with everyone you pay. Payments can hop across other people’s channels using HTLCs, hash time lock contracts, the same primitive behind atomic swaps. Routing uses onion routing in the Tor sense: an intermediate node learns the amount and nothing else, neither the true source nor the final destination.
The hops do not need to be trusted, and that is engineering rather than a promise. Time locks decrease along the path, which makes the route atomic: every leg settles or every leg rolls back. Nobody in the middle holds your money as a favour; each holds a conditional claim that expires.
Finality and instantaneity are a trade, not a bug
The last contrast is the one people keep trying to argue away. Chain settlement is final in the way that matters: deep, global, irreversible — and slow. Channel balances are instant between the two parties and final to nobody else until a close lands on-chain. You cannot have both at once, because instant finality for two people is exactly the same thing as everyone else not being told yet.
Here is the honest table, and I will not pretend the right column is free:
| On-chain payment | In-channel payment | |
|---|---|---|
| Who records it | every full node on the network | only the two channel peers |
| Smallest unit | one satoshi | millisatoshi, and some implementations go below a satoshi |
| Cost structure | bid for block space per payment | buy one on-chain transaction to open, one to close |
| Settlement | probabilistic finality that deepens with blocks | instant between peers, final only after close |
| Privacy | permanent public record | never touches the public ledger |
| Failure handling | invalid transactions are rejected by consensus | stale states are valid and punished economically |
| Throughput ceiling | block space | your own bandwidth and your ability to clear |
The gains are real: finer granularity, better privacy, effectively instant settlement, and throughput limited by your bandwidth and clearing capacity rather than by the protocol.
The costs are also structural:
- You must be online to receive. A payment you cannot sign for is a payment that does not happen.
- Receiving is limited by inbound liquidity. Open a channel funded entirely by you and, on day one, you have capacity to send and none at all to receive.
- The cost shape changed, it did not vanish. You stopped buying block space per payment and started buying one transaction to open and one to close. If your volume is low, that is a worse deal.
- Force closing costs you time. You wait out the delay, and your commitment transaction carries a fee rate decided when it was signed.
- Small amounts fall on the floor. An HTLC too small to pay for its own multi-level transaction is treated as dust and trimmed away; the spec’s own example hands an in-flight payment worth a couple of thousand satoshis straight to the miners. Tiny payments in flight can simply be forfeited.
For the underlying model rather than the channel layer, UTXO versus the account model is where to start: Lightning is a UTXO-native idea, and it makes far less sense if your mental model of Bitcoin is balances in accounts.
I do not know how much of the world’s small payments ends up here, and I am suspicious of anyone who does. What I can tell you is which trade was made: permanence was traded for speed, and the gap was closed with a threat rather than a referee.
Two short testimonies
“I stopped describing it as instant money and started describing it as deferred accounting with a loaded gun pointed at both of us. That description has never failed me.” — someone who runs a routing node
“I force-closed during a fee spike and learned that my exit transaction had been priced on a quieter day. Nothing was stolen. I just waited, and I have never left a channel unattended since.” — someone who once force-closed during a fee spike
(The End)


