What is an ephemeral anchor and what problem(s) would their introduction address? What is their relation to anchor outputs in Lightning? Are ephemeral anchors a prerequisite for eltoo?

V3 and package RBF are discussed here.

Mailing list post introducing ephemeral anchors: https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2022-October/021036.html

Ephemeral anchors draft BIP: https://github.com/instagibbs/bips/blob/ephemeral_anchor/bip-ephemeralanchors.mediawiki

Bitcoin Optech covering ephemeral anchors: https://bitcoinops.org/en/newsletters/2022/12/07/

Ephemeral anchors discussed in an eltoo BOLT draft: https://github.com/instagibbs/bolts/blob/eltoo_draft/XX-eltoo-transactions.md#ephemeral-anchor-output

There will be a Bitcoin Core PR review club session on this on March 29th.

1 Answer 1


In the Bitcoin Core PR review club notes:

Ephemeral anchors are a special type of output that are watermarked (by policy only) via a short static output script. These, along with a few policy ground rules, enable a new, more general “CPFP Carveout” which can sidestep package limit pinning. It also allows relaxation of output script requirements, increasing smart contract composability.

In the draft BIP:

Ephemeral Anchors are a mempool policy carve-out that allows any value utxos, even 0-value dust, to be created, provided it is also consumed within the same mempool package. This ephemeral anchor is a "mutex lock" for the transaction, allowing for robust fee bumping by wallets, not requiring any special key material to do so, and avoiding all known transaction pinning vectors.

Greg Sanders elaborated on the Stephan Livera podcast:

It is this idea that you can attach an output that doesn't require any signatures or anything. In this case it could be a bare OP_TRUE output that can be zero value, that is essentially a hook, a lock on the transaction, where to get this transaction in the mempool you have to spend that output. Let's say you have two outputs and this anchor then a counterparty can only spend the other outputs if they also spend this special output. Because you have to spend it it will be spent. In this V3 regime there is only one child so they must be spent together. That makes it a lock on the parent transaction that says you have to spend this. Anyone can double spend these child spends. This unlocks the package limit pinning scenario where in the original commitment transaction it has two anchors. You can't get pinned because the outputs have to spent together along with this ephemeral anchor.

If we want to do splicing or make a channel all of the smart contract scripts have this thing that is a one block relative timelock, a one block CHECKSEQUENCEVERIFY. All of these outputs have them except for the anchors and this is because we are trying to stop package limit pinning. Ironically this sometimes can be incompatible with Miniscript and it also means you can't do smart things like "I want to splice into a new channel funding output but also not pin the other person".

You are adding on these extra adhoc measures to stop pinning but that breaks composability with other smart contracts. You'd love to splice directly to your Coinbase account or whatever but you might have to prove to your counterparty that I can't pin you in the package limit sense. But how do you prove that? It is Coinbase, it is not even your address. Maybe they have committed to a Taproot script, we don't know what that is. It breaks composability when you have to introspect all the outputs and look at them and say "Does it have a timelock on it?" That breaks a lot of things.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.