Note
Receiving Is a Live Act: Why a Lightning Payee Has to Be Awake to Get Paid
On Lightning, receiving is an interactive act with a deadline: the payee's node must be online to release the preimage before HTLCs expire. Async-payment proposals move that uptime, they do not remove it.
2026-11-18 · lightning, receive-only, htlc, cltv-expiry, invoice-expiry, async-payments, static-invoices, bolt-12, onion-messages, lsp, watchtowers, trampoline, tips, protocol-literacy, civil-liberties
Listen · 9 min · AI voice

An on-chain address can sleep. You print it, walk away, switch the phone off for a month, and payments still land, because securing them is the blockchain's job, not yours. A Lightning receiver can't do that. Getting paid over Lightning is something your node does, in real time, while the payer's money sits locked along the route waiting for an answer.
on Lightning, receiving is an interactive act with a deadline. The recipient's node must be online to release the preimage before the HTLCs expire, so "receive-only" still means "reachable." Async-payment designs move that burden onto an always-online counterparty. They don't remove it, and the counterparty learns things in return.
Earlier notes covered the receive-only setup, BOLT-12 offers, what a preimage proves, and what a Lightning Address points to. This one is about time: who has to be awake, and for how long.
The mechanism: a payment is a set of locks waiting on you
Bitcoin Optech's async-payments page puts it plainly: "For LN, the receiver needs to release a secret at the time a payment is received in order to secure that payment. This requires that both the sender and receiver of a payment both be online at the same time."
The secret is the payment preimage. Each hop on the route holds an HTLC locked to its hash and to a block height, cltv_expiry. BOLT #2 tells forwarding nodes that once an incoming HTLC's cltv_expiry has been reached, or is closer than the delta they need downstream, they "MUST fail that incoming HTLC." The final node gets a floor too: BOLT #4 says it must fail an HTLC whose cltv_expiry is "unreasonably near the present," and BOLT #11's c field (min_final_cltv_expiry_delta) defaults to 18 blocks.
So every payment is a short-lived contract. Until the recipient fulfils it, liquidity on every channel along the path is committed to an outcome nobody knows yet. If the recipient never answers, the HTLCs fail back and the payer is refunded. Nobody loses funds, and the tip simply never arrives.
There's a second clock: the invoice itself. BOLT #11's x field is the expiry in seconds, "Default is 3600 (1 hour) if not specified," and after it passes a payer "SHOULD NOT attempt a payment" and a payee "SHOULD NOT accept a payment." BOLT #12 invoices default to 7200 seconds, which the spec calls "generally a sufficient time for payment, even if new channels need to be opened."
What that means for a receive-only tip jar
A tip jar feels passive: post a QR code, wait. Lightning makes it active in three places.
- Someone has to mint the invoice. A BOLT-11 invoice carries a fresh payment hash, so something holding the receiving node's keys must be awake to create it. With an offer, the payer's
invoice_requesttravels by onion message, and an offline recipient can't answer. The offers note made this point: no reply, no invoice to pay. - Someone has to settle. Even a pre-generated invoice needs the node online when the HTLC arrives, to check it and release the preimage before expiry.
- "Always reachable" usually means someone else's server. Hosted Lightning Address and LNURL services feel asynchronous because their node is always on. Whether they hold your funds or forward to you is the custody question from earlier notes. The liveness requirement didn't go away. It moved.
Hold invoices show the same mechanism used on purpose. Optech describes them as invoices "where the receiver doesn't immediately release the preimage," then accepts, rejects, or lets the payment time out, and links the topic to channel jamming. A receiver that sits on HTLCs, deliberately or because it fell asleep mid-payment, ties up other people's channels until the locks expire.
What async payments change
The developer community has treated this as a real problem. Optech notes a 2021 discussion about letting a forwarding node "hold a payment for a receiving node until the receiver was known to be online," and that the best-described trustless method needed PTLCs, which in Optech's wording "have not yet been added to LN as of the end of 2022." A trampoline-relay alternative was also discussed, and Optech lists Eclair work on a basic form of it.
The concrete spec proposals are two open pull requests on lightning/bolts, both still open, not merged, when this was checked:
- PR #989, "Async Payments: Add the ability to hold HTLCs before forwarding (FEAT 52/53)." The sender marks an HTLC with
hold_htlc. Its counterparty "MUST NOT forward the HTLC until a correspondingrelease_held_htlconion message is received." The recipient sends that message when it comes online. In the PR's words: "As long as the final recipients' counterparty is online and storing onion messages for the recipient, the recipient can reply to the onion message when they come online, unblock the HTLC, and expect to receive it quickly thereafter." - PR #1149, "Support async payments in BOLT 12." The often-offline recipient gives "some always-online node" — the diff names its channel counterparty, wallet vendor, or another node it has an out-of-band relationship with — a static invoice with no
invoice_payment_hashand no amount. Its offer's blinded paths lead to that node, which answersinvoice_requests on its behalf. The payer picks the preimage itself (sender_provided_payment_preimage), and the static invoice's default expiry is two weeks.
Optech also lists LDK merges implementing client- and server-side async-payment logic and support for paying static BOLT-12 invoices. Implementation is ahead of the spec text here, and support varies by implementation.
What it does not solve
- Someone still has to be awake. The sender's counterparty holds the HTLC, the recipient's counterparty stores the onion messages, and another node serves the static invoice. That's at least one always-online party for each payment.
- That party learns timing. Whoever stores your messages or serves your static invoice sees when requests arrive and when you come online to collect them. Blinded paths hide topology from the payer, not your schedule from your own counterparty.
- The proof of payment changes. PR #1149's diff says it outright: "Payers will not get proofs in the case that they received a static invoice from the payee." If the payer chose the preimage, holding it proves nothing about the recipient. The narrow receipt from the preimage note gets narrower.
- Locks still expire. A held HTLC is still an HTLC with a
cltv_expiry. If the recipient stays offline long enough, it fails back. - Watchtowers don't receive for you. Optech defines them as monitoring "the block chain for transactions that may cause one of their users to lose funds," so a client can be offline "without having to worry about their funds being stolen." That protects channel state you already have. A watchtower doesn't release preimages, answer invoice requests, or collect tips.
Why this travels
People whose connectivity is intermittent, expensive, or watched pay the most for "must be online to receive," whether that's a phone on a metered plan, a node behind a flaky link, or someone who would rather not run a server that announces when they're active. Async designs help them, and they ask those people to trust some always-on node with their timing. That's a fair trade to make knowingly, and a poor one to make by accident.
What this is not
This note does not rank or recommend wallets, LSPs, or hosted services, and it isn't custody advice. It doesn't discuss prices, amounts, swaps, or yields. It doesn't claim PRs #989 or #1149 are final or widely deployed; both were open when checked, and wire details may change. It doesn't say Lightning is broken for tips. It says receiving has a cost in uptime, and you should know who is paying it.
Related on CryptoDecentral
- Self-Custody Without Verify-Before-Trust Is a Slogan
- Privacy pillar
- Receive-Only Lightning Is Not a Merchant Stack
- A BOLT-12 Offer Is Not a Reusable Invoice
- A Preimage Is Not a Receipt
- A Name Is a Pointer, Not a Key
Further reading (primary)
- BOLT #2 — Peer protocol (HTLC forwarding,
cltv_expiryfailure rules) - BOLT #4 — Onion routing (final-node checks,
min_final_cltv_expiry_delta) - BOLT #11 — Invoice protocol (
xexpiry field,cfield) - BOLT #12 — Offers (
invoice_relative_expiry, onion-message invoice requests) - lightning/bolts PR #989 — Hold HTLCs before forwarding (open)
- lightning/bolts PR #1149 — Async payments in BOLT 12 / static invoices (open)
- Bitcoin Optech — Async payments
- Bitcoin Optech — Hold invoices
- Bitcoin Optech — Trampoline payments
- Bitcoin Optech — Watchtowers
Sources
- https://github.com/lightning/bolts/blob/master/02-peer-protocol.md
- https://github.com/lightning/bolts/blob/master/04-onion-routing.md
- https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
- https://github.com/lightning/bolts/blob/master/12-offer-encoding.md
- https://github.com/lightning/bolts/pull/989
- https://github.com/lightning/bolts/pull/1149
- https://bitcoinops.org/en/topics/async-payments/
- https://bitcoinops.org/en/topics/watchtowers/
- https://bitcoinops.org/en/topics/hold-invoices/
- https://bitcoinops.org/en/topics/trampoline-payments/
- https://cryptodecentral.co.za/notes/lightning-receive-only-tips
- https://cryptodecentral.co.za/notes/lightning-bolt12-offers-receive-only
- https://cryptodecentral.co.za/notes/lightning-preimage-is-not-a-receipt
- https://cryptodecentral.co.za/notes/lightning-address-is-a-pointer-not-a-key