Glossary

FROST Coordinator

The FROST coordinator collects commitments and signature shares from signers but never learns the private key.

Key Takeaways

  • The FROST coordinator orchestrates FROST signing rounds by collecting nonce commitments, distributing the aggregated commitment list, gathering partial signatures, and assembling the final threshold signature.
  • The coordinator never holds a key share and cannot forge signatures: even a fully malicious coordinator colluding with up to t−1 signers cannot produce a valid signature without reaching the threshold.
  • Coordinator compromise affects liveness (the ability to complete signing), not safety (the ability to steal funds). Protocols like ROAST and Spark's distributed operator network mitigate this liveness risk.

What Is a FROST Coordinator?

A FROST coordinator is the party that manages communication during a FROST threshold signing session. FROST (Flexible Round-Optimized Schnorr Threshold signatures), standardized in IETF RFC 9591, allows any t-of-n signers to cooperatively produce a valid Schnorr signature. The coordinator is the message router that makes this cooperation possible without requiring every signer to communicate directly with every other signer.

Think of the coordinator as a conference call operator: it connects the participants, relays messages between them, and announces the result, but it never speaks on their behalf and cannot make decisions for them. The coordinator does not need a key share of its own and gains no cryptographic advantage from seeing the messages it relays. This is a deliberate design property of FROST that separates the orchestration role from the signing role.

How It Works

The FROST signing protocol runs in two rounds. The coordinator manages both rounds, selecting the signing set and the message to be signed, then shepherding the data through each step.

Round 1: Commitment Collection

  1. The coordinator selects a set S of t signers from the full group of n and broadcasts the message m to be signed
  2. Each selected signer generates a fresh nonce pair (a hiding nonce and a binding nonce) and sends the corresponding commitment pair to the coordinator
  3. The coordinator collects all t commitment pairs and assembles them into a commitment list
  4. The coordinator distributes this aggregated commitment list back to every signer in S

Each signer's nonce pair is single-use: it must never be reused across signing sessions. If a session aborts, signers must discard the nonces generated for that session and produce fresh ones for any retry. Nonce reuse can leak a signer's signing share, compromising the entire scheme.

Round 2: Signature Share Generation and Aggregation

  1. Each signer uses the aggregated commitment list, the message m, and their own private signing share to compute a partial signature (signature share)
  2. Each signer sends their signature share back to the coordinator
  3. The coordinator verifies each signature share against the signer's public verification share, as defined in RFC 9591 Section 5.3
  4. If all shares verify, the coordinator sums them into a single Schnorr signature (R, z)
  5. The coordinator verifies the final aggregate signature against the group's public key before publishing it
// Simplified FROST coordinator aggregation (pseudocode)
function aggregate(commitmentList, signatureShares, groupPublicKey, message) {
  // Verify each signer's share individually
  for (const share of signatureShares) {
    if (!verifyShare(share, commitmentList, groupPublicKey, message)) {
      abort("Invalid share from signer " + share.signerID);
    }
  }

  // Sum all signature shares into the final z component
  const z = signatureShares.reduce((sum, s) => sum + s.z, 0n) % order;

  // Compute the group commitment R
  const R = computeGroupCommitment(commitmentList);

  // Verify the aggregate signature before publishing
  const signature = { R, z };
  assert(verifySchnorr(signature, groupPublicKey, message));
  return signature;
}

Identifiable Abort

Per RFC 9591 Section 5.4, the coordinator's per-share verification step enables identifiable abort: if a signer submits an invalid share (whether due to malice or a software bug), the coordinator can pinpoint exactly which signer misbehaved and exclude them from future sessions. Without this check, a single bad share would silently produce an invalid aggregate signature.

Trust Model: Liveness vs. Safety

The FROST coordinator occupies an unusual position in the trust model. It is trusted for liveness but not for safety:

  • Safety (unforgeability): a malicious coordinator cannot forge a signature. Even if the coordinator colludes with up to t−1 signers, the threshold requirement means they still cannot produce a valid signature. The coordinator sees nonce commitments and signature shares, but these do not reveal signers' private key shares
  • Liveness (availability): a malicious coordinator can refuse to relay messages, selectively drop commitments or shares, or simply go offline. Any of these actions prevents the signing session from completing, creating a denial-of-service condition

This distinction is critical. Compromising the coordinator cannot steal funds, but it can prevent transactions from being signed. For protocols that rely on timely signing (such as statechain transfers or force-close deadlines), liveness failures are a real operational risk even though they are not a custody risk.

Can the Coordinator Role Rotate?

Yes. The coordinator is stateless between signing sessions: it holds no long-lived secrets and accumulates no privileged state. Any party with network connectivity to the signers can serve as coordinator for a given session. This means the role can rotate per-session, be assigned round-robin, or even be eliminated entirely if signers communicate through a broadcast channel (RFC 9591 discusses removing the coordinator role in its security considerations).

Mitigating Coordinator Liveness Risk

Several approaches address the coordinator's single point of failure for liveness:

ROAST: Robust Signing Sessions

ROAST (Robust Asynchronous Schnorr Threshold signatures) is a wrapper protocol around FROST that runs multiple parallel signing sessions through a coordinator. When a signer is unresponsive or submits an invalid share, ROAST can complete signing through an alternative session with a different subset of signers. This guarantees that signing completes as long as at least t honest signers are reachable, even if up to n−t signers misbehave.

Distributed Coordinator Networks

Instead of relying on a single coordinator, protocols can distribute the coordinator function across multiple independent operators. If one coordinator node fails, another can take over. This converts a single point of failure into a distributed system where liveness depends on at least one coordinator being available.

Spark's Approach

Spark distributes the coordinator role across its network of Signing Operators (SOs). When a user initiates a transfer, their request goes to one SO acting as coordinator, which selects a subset of t operators from the pool. Because any SO can serve as coordinator and any t-of-n subset can sign, the system tolerates individual operator failures without stalling. The user's own participation is also required for every signing operation, ensuring that the operator set alone cannot move funds. This design gives Spark both the fault tolerance of threshold signing and the self-custodial guarantee that the user always retains control.

Use Cases

The coordinator pattern appears wherever FROST or similar threshold signing protocols are deployed:

  • Layer 2 protocols: Spark uses a coordinator to orchestrate vUTXO transfers between users and operators, producing on-chain-compatible Taproot signatures
  • Corporate treasury management: organizations using t-of-n custody can designate one party (or rotate the role) as coordinator to manage signing ceremonies without giving that party spending authority
  • Federated mints: federations of guardians use a coordinator-like role to aggregate signing for mint and redeem operations across the federation
  • DKG ceremonies: the coordinator pattern also applies during distributed key generation, where a facilitator collects and distributes commitment data among participants
  • Cross-chain bridges: threshold-signature bridges use coordinators to manage signing across validator sets, where the coordinator aggregates attestations before publishing to the destination chain

Risks and Considerations

Denial of Service

A compromised or malfunctioning coordinator can halt all signing activity. For protocols where timely signing is critical (force-close deadlines, time-sensitive transfers), this liveness failure can have financial consequences even though no funds are directly at risk of theft. Mitigation strategies include coordinator redundancy, automatic failover, and the ROAST protocol.

Message Manipulation

A malicious coordinator could attempt to send different commitment lists to different signers or alter the message being signed. FROST's security proof assumes that all signers receive the same commitment list and message. Implementations should have signers independently verify the commitment list and the message hash before producing their signature share. If signers blindly trust the coordinator's relayed data, targeted manipulation attacks become possible.

Nonce Exposure Through Aborted Sessions

A malicious coordinator could repeatedly initiate signing sessions and abort them, attempting to gather nonce commitments from signers. If a signer reuses a nonce across sessions (violating the protocol), this can leak the signer's private share. Correct implementations must generate fresh nonces per session and discard them on abort. The coordinator's ability to trigger session aborts makes proper nonce hygiene especially important.

Coordinator Selection and Centralization

If the same party always serves as coordinator, it becomes a de facto centralization point. Even though the coordinator cannot forge signatures, persistent coordinator control gives one party gatekeeping power over when and whether signing occurs. Rotating the coordinator role, using randomized selection, or distributing it across multiple nodes (as Spark does) reduces this centralization risk. See the coordinator trust glossary entry for a broader discussion of trust assumptions in coordinator-based protocols.

For a deeper technical overview of how FROST signing works end-to-end, see the FROST threshold signatures explained research article.

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.