Glossary

Partial Signature

A partial signature is one participant's contribution to a threshold signature, combined with others to form a valid signature.

Key Takeaways

  • A partial signature is one signer's individual contribution in a threshold signature scheme: each participant computes a partial signature using their signing share, and the results are combined into a single valid signature.
  • In FROST signing, partial signatures can be verified independently before aggregation, allowing the coordinator to detect and identify misbehaving signers without restarting from scratch.
  • Unlike multisig, where each signature is independently valid on-chain, partial signatures are not valid on their own: they only produce a valid Schnorr signature when combined through signature aggregation.

What Is a Partial Signature?

A partial signature is one participant's cryptographic contribution to a collaborative signing process. In a threshold signature scheme like FROST, a group of signers each hold a key share rather than a complete private key. When the group wants to sign a message, each participant independently computes a partial signature using their key share, the message being signed, and the aggregated nonce commitments from all participating signers. These partial signatures are then combined to produce a single, standard Schnorr signature that verifies against the group's public key.

The term "partial" reflects the fact that no individual signer's output constitutes a complete, valid signature. A partial signature is meaningful only in the context of the full signing session: it must be aggregated with the partial signatures from at least t-1 other participants (where t is the threshold) to produce something that any verifier would accept. This design ensures that no single participant can unilaterally sign a message, even if they possess their own key share.

How It Works

Partial signature generation is the core computation in round two of the FROST signing protocol, as defined in RFC 9591. The process builds on a distributed key generation phase that has already distributed key shares across the group.

  1. Each signer in the signing quorum generates a pair of random nonce values (d_i, e_i) and publishes the corresponding nonce commitments (D_i, E_i) to the other participants
  2. The coordinator collects all nonce commitments and distributes them to every signer, along with the message to be signed
  3. Each signer computes a binding factor (ρ_i) from the full set of commitments and their own index, then derives the group commitment R and the challenge c using the Fiat-Shamir transform
  4. Each signer computes their partial signature using the formula: z_i = d_i + ρ_i·e_i + λ_i·s_i·c
  5. The coordinator collects all partial signatures, optionally verifies each one, and sums them to produce the final signature (R, z) where z = Σz_i

The Partial Signature Formula

The partial signature z_i for signer i is computed as:

z_i = d_i + ρ_i · e_i + λ_i · s_i · c

Where:
  d_i, e_i  = signer's secret nonce values
  ρ_i       = binding factor (derived from all commitments)
  λ_i       = Lagrange coefficient for signer i in the current signing set
  s_i       = signer's private key share (signing share)
  c         = challenge hash (from group commitment R and the message)

The linearity of Schnorr signatures is what makes this aggregation possible. Because the equation is linear, summing the z_i values across all participating signers produces a z that corresponds to the full secret key, without any single party ever reconstructing it. The Lagrange coefficients (λ_i) ensure that any valid subset of t signers will reconstruct the same aggregate, regardless of which specific participants are involved.

Verifying Partial Signatures Before Aggregation

A critical property of partial signatures in FROST is that they can be checked individually before combining them. The coordinator verifies each partial signature z_i by checking:

z_i · G == R_i + (λ_i · c) · Y_i

Where:
  G    = generator point
  R_i  = signer's individual nonce commitment (D_i + ρ_i · E_i)
  Y_i  = signer's public key share (verification share)
  λ_i  = Lagrange coefficient
  c    = challenge

If this check fails for any signer, the coordinator knows exactly which participant submitted an invalid partial signature. This enables identifiable abort: the protocol halts, the faulty signer is excluded, and the remaining honest signers can restart with a new session. Without per-share verification, a single corrupted partial signature would produce an invalid aggregate signature with no way to attribute the fault.

Partial Signatures vs. Multisig

The distinction between partial signatures and multisig signatures is fundamental. In a traditional multisig scheme (such as Bitcoin's OP_CHECKMULTISIG), each signer holds a complete, independent private key. Each signature they produce is a fully valid signature that can be verified on its own against that signer's public key. The blockchain then checks that m of n signatures are valid.

Partial signatures work differently. No signer holds a complete key; they hold only a key share. Their partial signature is not a valid Schnorr signature on its own and cannot be verified against any single public key in the way a standalone signature can. It can only be checked using the per-share verification equation described above, which requires knowledge of the signer's public key share and the session's nonce data.

PropertyMultisigPartial Signatures (FROST)
Key structureEach signer holds a full keyEach signer holds a key share
Individual validityEach signature is independently validPartial signatures are not valid alone
On-chain footprintMultiple signatures visibleSingle aggregated signature
PrivacyNumber of signers revealedIndistinguishable from single-signer
Interaction requirementSigners can act independentlySigners must coordinate in rounds
Chain support neededRequires script-level supportWorks with any Schnorr verifier

This distinction has practical implications for transaction size, privacy, and interoperability. A 2-of-3 multisig transaction on Bitcoin carries multiple signatures and reveals the signing policy on-chain. A 2-of-3 FROST signing session produces a single aggregated signature that is byte-for-byte identical to a standard Schnorr signature, revealing nothing about the threshold structure. For a deeper comparison, see the MuSig2 multisignatures research article.

Use Cases

Threshold Custody

Partial signatures enable custodial setups where multiple parties must cooperate to authorize a transaction without any single party being able to sign alone. In a 3-of-5 threshold signature configuration, three participants each produce a partial signature, and these are combined into one valid signature. If a participant's device is compromised, the attacker gains only a key share, which is useless without the remaining shares.

Bitcoin Layer 2 Protocols

Protocols like Spark use FROST partial signatures to manage off-chain Bitcoin transactions. When transferring a virtual UTXO, Spark operators and the user each contribute partial signatures using their respective key shares, producing a valid cooperatively signed transaction. The signing round performance is critical for user experience in these systems, as each transfer requires partial signature generation and aggregation.

Distributed Signing Services

Organizations that require geographically distributed signing (for disaster recovery or regulatory compliance) use partial signatures so that signing authority is split across data centers, hardware security modules, or custodians in different jurisdictions. Each location computes a partial signature locally, and only the aggregated result leaves the network.

Key Rotation Without Spending

Partial signatures from a DKG ceremony can be refreshed: participants generate new key shares that reconstruct the same group key, without changing the public key or moving funds on-chain. The new shares produce partial signatures that aggregate to the same public key, so the rotation is invisible to outside observers.

Risks and Considerations

Nonce Reuse

If a signer reuses the same nonce values (d_i, e_i) across two different signing sessions with different messages, an attacker can algebraically extract that signer's private key share from the two partial signatures. FROST mitigates this by deriving binding factors from the full set of commitments, but implementations must ensure that nonces are generated fresh for every session. Using deterministic nonces derived from the key share and message is one approach, though it introduces its own tradeoffs in multi-session scenarios.

Coordinator Trust

The FROST coordinator collects partial signatures and performs aggregation. While the coordinator cannot forge partial signatures (they lack key shares), a malicious coordinator could selectively exclude valid partial signatures, present inconsistent nonce commitments to different signers, or refuse to publish the final signature. The coordinator is trusted for liveness, not for safety: they cannot steal funds, but they can stall the protocol.

Communication Overhead

Producing partial signatures requires at least two rounds of communication among signers: one round to exchange nonce commitments and one to exchange partial signatures. This interactive requirement means that all participants in the signing quorum must be online simultaneously, which can be a challenge for mobile or offline-first applications. Pre-processing nonce commitments can reduce signing to a single round, at the cost of storing nonce state.

Share Validity and Abort

If a signer submits an invalid partial signature (whether through malice, bugs, or corruption), the coordinator must detect it through per-share verification, exclude the faulty participant, and restart with a new quorum. This identifiable abort mechanism adds resilience but also latency: a persistent attacker who controls multiple shares just below the threshold can repeatedly force restarts.

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.