Live prices are currently unavailable — the exchange feed could not be reached and no recent cached reading is held.

Protocol & Mining

Bitcoin Statechains Explained

A statechain is a proposed way of transferring ownership of an unspent output without moving it on-chain. The design relies on a key-deletion assumption: the entity that helps move the output is supposed to destroy its share of the key each time ownership changes. It is a proposal, not a deployed feature, and the assumption it rests on is the part worth understanding.

A proposal, not a deployed feature

Statechains were described in a 2018 mailing-list post by Ruben Somsen as a construction for transferring the ownership of a bitcoin output off-chain. The proposal has been discussed and refined since, but it has not been adopted as a consensus change, it is not part of Bitcoin Core, and there is no protocol-level support for it. Any description of statechains is therefore a description of a design and its claimed properties, not of something a user can rely on today.

That framing matters because the design is often discussed alongside deployed systems such as the Lightning Network, and the two are not the same kind of thing. Lightning is a deployed second-layer protocol with real channels and real capital committed to it. Statechains are a proposal whose security argument depends on an assumption that has no deployed analogue. Treating them as equivalent would misstate both.

How the proposed design works

The construction begins with a single on-chain output that is controlled by a key which is split between the owner and a statechain entity. Neither party holds the whole key, so neither can spend the output alone. The output stays where it is; what changes over time is who the owner is and what share of the key they hold.

To transfer ownership, the current owner and the entity cooperate to produce a new key share for the incoming owner and to re-sign the output so that it is controlled by the new owner together with the entity. The outgoing owner's share is supposed to be deleted. If the deletion actually happens, the outgoing owner can no longer participate in a spend, and the incoming owner holds the only share that matters. The transfer is complete without any on-chain transaction, which is the source of the design's efficiency claim: an arbitrary number of ownership changes can occur against a single output.

The output is eventually spent on-chain, either by the current owner cooperating with the entity or, if the entity is unresponsive, by the owner after a timelock expires. The timelock is the escape hatch: it guarantees that a cooperative entity cannot freeze the funds permanently, because the owner can always wait and then spend unilaterally. The design's own documentation describes the key sharing, the re-signing procedure and the timelock path in more detail than is possible here.

The key-deletion assumption

Everything above depends on the outgoing owner genuinely destroying their key share. If they keep a copy, they retain the ability to cooperate with the entity — or to collude with it — and spend an output they no longer own. The design cannot enforce deletion, because deletion happens inside a party's own software and on their own hardware. It is an assumption about behaviour, not a property the protocol can verify.

This is the sharpest difference between statechains and a construction like Lightning. A Lightning channel's security argument rests on penalties that are enforced by the blockchain: a party that broadcasts an outdated state can be punished by a revocation transaction that takes their funds. A statechain's security argument rests on a party choosing to forget something. The first is verifiable by anyone reading the chain; the second is not verifiable by anyone.

The design's response is that the assumption is reasonable in practice for a cooperative entity with a reputation to protect, and that the timelock limits the damage an unresponsive entity can do. That may be a fair judgement, but it is a judgement about incentives rather than a cryptographic guarantee, and a reader evaluating the proposal should weigh it as such. The proposal's own discussion acknowledges the assumption rather than hiding it.

Trade-offs and open questions

The efficiency case is genuine. Because ownership changes do not touch the chain, a statechain can move an output many times for the cost of one on-chain transaction, and the transfers are not visible to anyone watching the chain. That is a meaningful improvement over an on-chain transfer for the specific case of moving ownership without changing the underlying output, and it is why the proposal has continued to attract attention.

The costs are equally real. The entity is a liveness dependency: if it disappears, the owner must wait out the timelock before spending, and during that wait the funds are not usable. The entity also learns the history of ownership, because it participates in every transfer, which is a privacy cost that an on-chain transfer does not have. And the key-deletion assumption means the security model is weaker than a construction whose penalties are enforced on-chain.

There are also questions the proposal does not fully settle. What happens if the entity and a former owner collude is the obvious one, and the answer depends on the deletion assumption holding. How the entity is compensated, and whether that compensation creates an incentive to behave badly, is another. These are the questions a reader should carry away from any description of statechains: the design is interesting precisely because its trade-offs are explicit, and it should be evaluated on those trade-offs rather than on the efficiency claim alone.

Sources and references

The description of the proposed construction, the key-deletion assumption and the timelock path is taken from the original proposal and from the discussion that followed it. Statechains are presented here as a proposal; no deployment, adoption or incident is asserted.

  • The original statechain proposal. Ruben Somsen, Bitcoin-dev mailing list — Statechains: introduces the design, the shared key between owner and entity, and the transfer procedure that relies on deleting the previous owner's share.
  • The statechain specification and its security discussion. CommerceBlock, Mercury — Statechains specification: sets out the key sharing, the re-signing procedure and the timelock escape path in implementation terms.
  • Timelocks and the unilateral spend path. Bitcoin, BIP 65: OP_CHECKLOCKTIMEVERIFY: defines the absolute timelock opcode that a statechain's unilateral recovery path would depend on.
  • The penalty-based alternative for comparison. Poon and Dryja, The Bitcoin Lightning Network: Scalable Off-Chain Instant Payments: describes revocation and penalty transactions that are enforced on-chain, which is the property a statechain's key-deletion assumption does not provide.