Glossary

Blind Co-Signing

Blind co-signing lets a server contribute a signature share without learning what transaction it is signing, preserving user privacy in statechain and threshold signature protocols.

Key Takeaways

  • Blind co-signing allows a server to produce a signing share without learning the transaction it is helping to sign, the aggregate public key, or the final signature.
  • The technique is central to privacy-preserving statechain protocols: it prevents the statechain entity from linking transfers, learning balances, or identifying which UTXOs it controls on-chain.
  • Unlike standard multisig where every signer sees the full transaction, blind co-signing uses cryptographic blinding so one party contributes to the signature while remaining oblivious to its contents.

What Is Blind Co-Signing?

Blind co-signing is a cryptographic technique in which a server holds a private key share and participates in producing a valid signature, but a blinding layer prevents the server from seeing the message, the aggregate public key, or the resulting signature. The server contributes its partial computation honestly, yet learns nothing about the transaction it helped authorize.

The concept was introduced in the context of statechains, where a statechain entity (SE) must co-sign ownership transfers but should not be able to censor, surveil, or collude against users. Ruben Somsen formalized this in a 2019 bitcoin-dev proposal describing a "minimalistic blind signing server" with only two operations: creating a new signing key and blindly co-signing a message. Tom Trevethan later built on the idea in the Mercury Layer protocol, using a blinded variant of MuSig2 to achieve full transaction privacy from the server.

How It Works

Blind co-signing combines two-party Schnorr signatures with a blinding protocol. In a standard two-party signing setup, both parties see the message and can verify the final signature. In the blinded variant, the user wraps the message and nonce data in a blinding factor before sending it to the server, so the server never sees the raw values.

Blinded MuSig2 Protocol

Mercury Layer, the most prominent implementation, uses a blinded variant of the MuSig2 protocol on Taproot addresses. The process works as follows:

  1. The server (party 1) and the user (party 2) each hold a private key share. Together, these shares correspond to a single aggregate public key that locks a UTXO on-chain.
  2. When the user wants to sign a transaction, both parties exchange nonces as in standard MuSig2. However, the user applies a blinding factor to the challenge hash before sending it to the server.
  3. The server computes its partial signature using its key share and the blinded challenge. It returns this partial signature to the user.
  4. The user removes the blinding factor and combines both partial signatures into a valid Schnorr signature for the transaction.

Because of the blinding, the server never learns the full shared public key, the transaction being signed, or the final combined signature.

Key Share Update on Transfer

When a statechain coin is transferred to a new owner, the server's key share must be updated so the new owner can co-sign with the server while the previous owner loses signing ability. This update also uses blinding:

  1. The server generates a random blinding nonce e and sends it to the current owner.
  2. The current owner computes t1 = e + x2 (adding their private key x2 to the nonce) and passes this value to the new owner through an encrypted channel.
  3. The new owner subtracts their own private key: t2 = t1 - x3 = e + x2 - x3, and sends t2 back to the server.
  4. The server updates its key share: x1_new = x1 + t2 - e = x1 + x2 - x3. The blinding nonce e cancels out, leaving the server with a new share that, combined with the new owner's key x3, produces the same aggregate public key.
  5. The server deletes its old key share x1, ensuring it can no longer sign with the previous owner.
// Key share update (simplified)
// Server share: x1, Sender key: x2, Receiver key: x3

server_nonce = random(e)        // Server generates blinding nonce
t1 = e + x2                     // Sender adds private key
t2 = t1 - x3                    // Receiver subtracts their key
x1_new = x1 + t2 - e            // Server updates share
// x1_new + x3 = x1 + x2 = original aggregate
delete(x1)                       // Old share destroyed

The key aggregation coefficient is set to 1 for each key in this scheme. To prevent rogue-key attacks (which this coefficient normally guards against in standard MuSig2), each party instead proves knowledge of their private key by signing the statechain state.

Contrast with Standard Multisig

In a conventional multisig arrangement, every co-signer sees the complete transaction before signing it. This is by design: each party verifies the transaction details to ensure they agree with what is being authorized. The tradeoff is that every co-signer learns the full transaction graph, amounts, and addresses involved.

Blind co-signing inverts this model for the server party. The user still sees everything (they construct the transaction), but the server contributes its signature share without any visibility. This asymmetry is intentional: the server exists to enforce a protocol rule (preventing double-spending by limiting how many times it signs), not to approve specific transactions.

PropertyStandard MultisigBlind Co-Signing
Server sees transactionYesNo
Server sees aggregate keyYesNo
Server can link transfersYesNo
Server can censor transactionsYesNo (signs blindly)
Server enforces signing countN/AYes (reports signature count)
Verification modelServer-sideClient-side

Use Cases

Privacy-Preserving Statechains

The primary use case for blind co-signing is in statechain protocols. Without blinding, the statechain entity would see every transaction it co-signs, learning which UTXOs it controls, who transfers coins, and when. This creates a surveillance risk and a potential censorship vector.

With blind co-signing, the SE operates as a minimal blind signing server. It knows how many times it has signed for a given key, but nothing about the content of those signatures. Off-chain transfers leave no blockchain footprint, and even the entity facilitating them cannot link transfers to specific users or amounts. For a deeper look at how statechains work, see the statechains deep dive.

Collusion Resistance

Because the server does not know what it is signing, collusion between the server and a previous owner becomes significantly harder. A colluding server in a non-blinded protocol could identify the UTXO and help a previous owner double-spend. A blinded server cannot even tell which UTXO it co-controls, reducing the attack surface to the server unilaterally refusing to sign at all.

Threshold Server Architectures

Blind co-signing can be extended to threshold signature schemes where the server role is split across a federation. Each federation member holds a share of the server's key and contributes a blinded partial signature. This distributes trust: an attacker would need to compromise a threshold of federation members, all of whom are individually blind to the transactions they help sign.

Enhanced CoinJoin-Style Privacy

Statechain transfers using blind co-signing can be combined with blind signatures and swapping protocols to achieve CoinSwap-like privacy. Because the SE cannot link inputs to outputs, users can swap statechain coins with other users and break the transaction graph without on-chain activity.

Why It Matters

Blind co-signing addresses a fundamental tension in custodial and semi-custodial Bitcoin systems: the entity that helps secure funds typically sees everything about how those funds move. This creates privacy risks, regulatory exposure, and censorship vectors. By making the co-signing server cryptographically blind, protocols can offer the security benefits of multi-party signing without the surveillance costs.

For Bitcoin layer-2 solutions like Spark and other off-chain protocols, the principle behind blind co-signing is relevant to designing systems where operators facilitate transfers without becoming privacy bottlenecks. The less an operator knows, the less it can be compelled to censor, surveil, or selectively deny service.

Risks and Considerations

Client-Side Verification Burden

Because the server cannot see what it signs, it cannot enforce rules about the content or sequence of transactions. In statechain protocols, this means the server cannot verify that backup transactions follow the correct decrementing timelock order. The burden shifts to the receiving user, who must verify the full history of prior backup transactions. If a user skips this verification, they may accept a statechain coin with an invalid or conflicting backup chain.

Trust in Signature Count Reporting

The server's only role beyond signing is reporting how many times it has signed for a given key. Users rely on this count to detect unauthorized signing (which would indicate the server is colluding with a previous owner). If the server lies about the count, users cannot independently verify it. This makes the server's honesty about the count a residual trust assumption.

Key Deletion Trust Assumption

After a transfer, security depends on the server actually deleting its old key share. If the server retains old shares, it could collude with any previous owner to sign a conflicting transaction. This "delete-and-forget" trust assumption cannot be cryptographically enforced: the server must be trusted (or federated across multiple parties) to destroy old key material.

Rogue-Key Attack Surface

Setting the MuSig2 key aggregation coefficient to 1 (required for key share updates) removes the standard rogue-key protection built into the protocol. The replacement mechanism (proof of knowledge via statechain state signatures) must be correctly implemented. A flaw in this step could allow an attacker to register a crafted public key that lets them forge signatures without the server's cooperation.

Information Leakage Between Users

While the server is blinded, the transfer protocol between sender and receiver can still leak information. The sender must pass cryptographic material (the blinded key update value) to the receiver, and the communication channel used for this exchange may be observable. Some proposals extend blinding with zero-knowledge proofs to close this gap, but these add complexity and are still under active research.

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.