Glossary

Statechain Transfer

A statechain transfer moves UTXO ownership off-chain by rotating co-signing keys between sender and receiver through a statechain entity, without broadcasting an on-chain transaction.

Key Takeaways

  • A statechain transfer moves ownership of a UTXO off-chain by rotating the co-signing key shares between sender and receiver through a statechain entity, with no on-chain transaction required.
  • Each transfer produces a new backup transaction with a shorter timelock, ensuring the most recent owner can always exit to the base chain first if the statechain entity becomes unresponsive.
  • In basic statechains, the entire UTXO must transfer as a single unit: no partial amounts. Spark extends this model with a leaf-based architecture that enables arbitrary-amount off-chain transfers.

What Is a Statechain Transfer?

A statechain transfer is the process of changing ownership of a Bitcoin UTXO without broadcasting a transaction on the base chain. Instead of moving coins to a new address, the protocol rotates the cryptographic key shares that control the UTXO. The coin stays at the same on-chain address throughout its entire lifecycle on the statechain, but only the current owner holds a valid key share that can co-sign with the statechain entity (SE).

The concept was proposed by Ruben Somsen at Scaling Bitcoin 2018. His core insight was that Bitcoin ownership is ultimately about who holds the private key, not which address holds the coins. By splitting that private key into two shares and rotating the shares on each transfer, you can change who controls a UTXO without touching the blockchain at all. This makes statechain transfers instant, free, and invisible to on-chain observers.

How It Works

A statechain transfer involves three parties: the sender (current owner), the receiver (new owner), and the statechain entity (a server or distributed operator set). The UTXO is locked under a 2-of-2 key share arrangement where the full private key is never known by any single party. One share belongs to the current owner, the other to the SE.

The Three-Party Handshake

The transfer follows a coordinated sequence between sender, receiver, and SE:

  1. The sender initiates a transfer by notifying the SE that they want to pass ownership to a specified receiver. The sender provides their current key share (or a blinded version of it) to the SE.
  2. The SE and the receiver run a key generation protocol to produce a new pair of key shares. The critical property is that these new shares sum to the same aggregate private key that controls the UTXO. The SE gets a new share, and the receiver gets a new share, but neither learns the full key.
  3. The receiver creates a new backup transaction that spends the UTXO back to an address they control. This backup has a shorter timelock than the sender's backup. The SE co-signs this new backup transaction.
  4. The SE deletes its old key share (the one paired with the sender). After deletion, the sender's share becomes useless because it can no longer form a valid 2-of-2 signature with the SE.
  5. The SE updates its internal state to record the receiver as the current owner. The transfer is complete.

Backup Transaction and Timelock Decrement

Every owner in the statechain holds a pre-signed backup transaction that lets them exit to the base chain unilaterally. The backup is a pre-signed transaction that spends the UTXO to the owner's personal address, locked by an nLockTime value. The first owner's backup might have an nLockTime of block height h. The second owner's backup uses h - c, where c is a confirmation window (such as 144 blocks, roughly one day). The third owner uses h - 2c, and so on.

This decrementing structure ensures that the most recent owner can always broadcast their backup before any previous owner. If a former owner tries to broadcast an old backup, the current owner's backup has a shorter timelock and will confirm first. The pattern is conceptually similar to how eltoo (LN-Symmetry) handles state updates in payment channels.

Owner 1 backup: nLockTime = h        (e.g., block 900,000)
Owner 2 backup: nLockTime = h - c    (e.g., block 899,856)
Owner 3 backup: nLockTime = h - 2c   (e.g., block 899,712)
...
Owner N backup: nLockTime = h - (N-1)c

Where c = confirmation window (e.g., 144 blocks ≈ 1 day)

This creates a natural limit: once the timelock decrements reach the current block height, no more transfers can occur and the UTXO must settle on-chain.

Key Deletion and Finality

The security of a statechain transfer depends on the SE honestly deleting its old key share after each transfer. If the SE retains the old share, it could collude with a previous owner to steal the UTXO. This is the primary trust assumption in the statechain model: the SE must behave honestly regarding key deletion.

Key deletion cannot be cryptographically proven. To mitigate this risk, modern statechain implementations distribute the SE role across multiple independent operators using FROST threshold signatures. Under this model, the SE's key share is itself split among several operators. Theft would require a threshold of operators to collude with a previous owner, which is significantly harder than corrupting a single server. Spark, for example, uses a distributed operator set so that only one honest operator is needed to prevent theft.

Why the Entire UTXO Must Transfer

In basic statechains, ownership transfers apply to the entire UTXO. You cannot send half of a 0.1 BTC statechain coin to one person and keep the other half. This constraint exists because the UTXO on the base chain is a single indivisible output controlled by one aggregate key. Splitting it would require creating new outputs on-chain, which defeats the purpose of off-chain transfers.

This whole-UTXO requirement was a significant limitation of early statechain designs. Users had to pre-fund statechains in specific denominations (like 0.01 BTC or 0.001 BTC) and combine multiple statechain coins to approximate arbitrary amounts: similar to physical cash denominations.

Spark extends the statechain model by introducing a tree structure where the on-chain UTXO serves as the root and individual user balances exist as leaves. This leaf-based architecture enables partial transfers: a user can send any amount by splitting or merging leaves off-chain, while the on-chain UTXO remains unchanged. For a deeper look at how Spark builds on the statechain foundation, see the statechains deep dive and the Spark Layer 2 overview.

Use Cases

Instant Off-Chain Payments

Statechain transfers settle instantly between sender and receiver without waiting for block confirmations. This makes them useful for peer-to-peer payments, point-of-sale transactions, and any scenario where on-chain confirmation times are too slow. Unlike Lightning channels, no channel setup or liquidity management is required.

Private Bitcoin Transfers

Because statechain transfers happen off-chain, they leave no trace in the public blockchain. The UTXO sits at the same address regardless of how many times it changes hands. Chain analysis tools cannot detect ownership changes, making statechains a privacy-enhancing layer for Bitcoin.

Atomic Swaps and CoinSwap

Statechain transfers can be combined with atomic swaps to exchange statechain coins between users trustlessly. Two parties can swap statechain coins of different denominations (or even different assets) using adaptor signatures to guarantee atomicity: either both transfers complete or neither does.

Fee-Free Transfers

Statechain transfers do not pay miner fees because they never touch the blockchain. The only cost is whatever the SE charges for its coordination service. This makes statechains attractive for use cases where on-chain fee rates are prohibitive, particularly for smaller-value UTXOs that might otherwise become stranded.

Risks and Considerations

Trust in Key Deletion

The fundamental trust assumption is that the SE deletes old key shares. This cannot be verified externally. A malicious SE that retains old shares could reconstruct a valid signing key with any previous owner. Distributing the SE across multiple operators with threshold signatures reduces this risk but does not eliminate it entirely.

Limited Transfer Count

The decrementing timelock mechanism limits how many times a UTXO can change hands before it must settle on-chain. If the confirmation window is 144 blocks and the initial timelock is set one year ahead, the UTXO can support roughly 2,500 transfers before the timelocks are exhausted. After that, the current owner must perform a cooperative close or wait for the timelock to expire.

Whole-UTXO Constraint

In basic statechain implementations, the entire UTXO transfers as a unit. Users cannot send partial amounts without first settling on-chain and re-funding with the desired denomination. This friction limits usability for everyday payments, though protocols like Spark address this with off-chain splitting mechanisms.

SE Availability

The SE must be online and responsive to co-sign backup transactions and coordinate transfers. If the SE goes offline, users can still exit using their pre-signed backup transactions, but new transfers are impossible until the SE returns. A prolonged outage forces all users to settle on-chain.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.