FROST Threshold Signatures: How Two-Round Signing Works
FROST threshold signatures let a group of participants authorize a message using portions of one shared signing key, while producing a single Schnorr signature for the group’s public key. The protocol is useful to engineers designing distributed custody, wallet, and validator systems who need to understand how multiple operators can cooperate without collecting separate signatures on-chain. This explainer covers the signing flow, the assumptions around key shares and nonces, and the limits that remain even when no participant holds the complete key.
What Are FROST Threshold Signatures?
FROST stands for Flexible Round-Optimized Schnorr Threshold. It is a protocol in which participants each hold a share of a common signing secret. A configured threshold of them can cooperate to sign a message. The resulting signature verifies against one group public key, so a verifier can use an ordinary compatible Schnorr verification procedure rather than learning which participants took part.
The FROST specification, RFC 9591, defines a two-round signing protocol over selected prime-order groups with specified hash functions. The ZF FROST guide explains the participants, key shares, and signing flow in practical terms. The Zcash Foundation’s FROST repository provides Rust implementations for the supported ciphersuites; it is an implementation, not a substitute for assessing whether a protocol and library fit a particular application.
For a t-of-n group, n is the number of participants and t is the minimum number of shares required by the scheme. A 3-of-5 group, for example, is configured so that three participants can produce a signature without any one of them holding the complete signing key. That property depends on secure share generation and on fewer than the threshold number of shares being compromised.
Why FROST Exists
A single signing key concentrates authority and creates a single point of compromise or operational failure. Conventional multisignature systems distribute authority across several independent keys, but they may require a verifier, smart contract, or blockchain script to understand and enforce the multiple signatures. That can add complexity or make the signing policy visible in the resulting transaction.
Threshold signing offers a different model. The group divides one signing secret into shares and combines participants’ contributions into one signature under one public key. It can therefore distribute who can authorize a message without requiring the final verifier to check a list of independent signatures. FROST focuses on doing this for Schnorr signatures in two signing rounds, reducing coordination round trips compared with earlier multi-round approaches.
That compact output does not make the protocol trustless by itself. A system still needs a trustworthy key-generation process, secure communication, an agreed signing policy, and a way to handle unavailable or malicious participants. FROST also does not replace application-level authorization: a threshold group can collectively sign a message that its policy should have rejected.
How the FROST Signing Protocol Works
FROST signing has a setup phase and two interactive rounds. The coordinator may be one of the signers or a separate service. It coordinates messages; it should not need to reconstruct the group secret.
- Choose a signing set and message. The coordinator identifies the message and the participants for this session. The chosen set must contain at least the threshold number of participants. The message and participant set must be unambiguous to all signers.
- Round one—commitments. Each selected participant creates fresh secret nonces and sends commitments to the coordinator. A commitment reveals the public group element derived from a nonce, not the nonce itself. The coordinator gathers the commitments and distributes the complete set back to the selected signers.
- Round two—signature shares. Each signer uses its long-term key share, its secret nonces, the message, and the full commitment set to compute a signature share. Binding factors derived from the session data prevent contributions from being rearranged or reused as if they belonged to a different signing context.
- Aggregate and verify. The coordinator checks the returned shares and combines them into a single Schnorr signature. The final verifier checks that signature against the group’s public key and the signed message.
The complete selected set is part of the session: implementations generally require every participant selected for that signing session to return its share. If a selected signer drops out, the coordinator cannot simply omit the missing share from the already established session. It should abort and start a new session with a valid signer set and fresh nonces.
| Feature | Single-party Schnorr | Conventional multisignature | FROST threshold signing |
|---|---|---|---|
| Signing authority | One secret key | Multiple independent keys | One secret distributed as shares |
| Required cooperation | One keyholder | Several signers, as required by the policy | At least the configured threshold |
| Result seen by verifier | One signature for one public key | Multiple signatures or script/contract-enforced approvals | One signature for the group public key |
| Signing coordination | Local operation | Collect signatures according to the wallet or contract | Two protocol rounds plus coordination |
| Key setup | Generate one keypair | Generate and register independent keys | Create shares through a threshold setup procedure |
| Compatibility | Depends on the Schnorr scheme | Depends on the wallet, chain, script, or contract | Requires a compatible Schnorr ciphersuite and verifier |
FROST is not merely a more efficient way to serialize every multisig arrangement. A conventional multisig policy can use independent keys with different roles or rules; FROST distributes one signing key’s authority. Which model fits depends on how the application represents identities, verifies signatures, and handles recovery.
Participants, Shares, and Ciphersuites
Key shares and key generation
Each participant holds a secret share and a corresponding verification share. The group also has a verifying key used to check the final signature. The RFC describes the signing protocol, but key generation is not its main scope; it includes a trusted-dealer procedure in an appendix for completeness.
A trusted dealer can split a key into shares, but the complete secret exists in the dealer’s process during setup. Distributed key generation is a separate protocol that lets participants create shares without reconstructing the full secret at one participant. It has additional communication and security requirements. These methods are not interchangeable operational details: the chosen setup determines who must be trusted during enrollment, what records must be retained, and how participants can be replaced.
Threshold and signer set
The threshold determines both how many participants must cooperate and how many compromised shares may put the group at risk. A higher threshold can reduce the impact of a smaller number of compromised participants, but it can also make signing less available when members or their networks are offline. The group size and threshold should reflect independent operators and failure domains, not only a preferred availability number.
Nonces and session state
Each signature operation depends on fresh secret nonces. Reusing or predictably deriving them can expose the long-term key; the RFC specifically discusses nonce reuse attacks. Nonces and preprocessed commitments must therefore be treated as single-use state, with careful handling when sessions abort or processes restart. A signer must never publish its secret nonces or assume that a previous commitment can safely be reused.
Ciphersuites and limits
FROST is for Schnorr signatures, not ECDSA. RFC 9591 specifies ciphersuites for groups including Ed25519, Ed448, Ristretto255, P-256, and secp256k1. A ciphersuite determines details such as the group operations and hash functions; implementations and verifiers must agree on it. The RFC is an informational IRTF document, not an Internet Standards Track specification, and support for a curve does not guarantee that a given blockchain or wallet accepts the resulting signature format.
Where FROST Is Used
FROST can be considered for custody systems where an organization wants signing authority distributed across people, machines, or locations while keeping a single Schnorr public identity. It can also be relevant to wallet designs that need a compact signature format, or infrastructure that must continue signing when a limited number of participants are unavailable.
Distributed validator systems are another area where threshold signing concepts may appear, but DVT is a broader operating model involving validator duties, coordination, and slashing protection. Not every DVT implementation uses FROST. Similarly, a bridge may use threshold-controlled signing, but FROST alone does not verify cross-chain events or guarantee that the signers follow sound bridge policy.
The protocol is a poor fit when the application requires ECDSA, a chain does not accept a compatible Schnorr signature, or participants need distinct per-signer identities at verification time. A design should evaluate its verifier, transaction format, key lifecycle, and failure recovery before selecting FROST.
Getting Started: Evaluate an Implementation
Start with the exact ciphersuite and library supported by the target verifier. The ZF FROST project offers ciphersuite-specific Rust crates; its guide and API documentation should be treated as the source for supported features and safe usage. This minimal Rust setup adds the Ed25519 ciphersuite dependency for evaluation; it does not create keys or sign a production message:
cargo new --lib frost-evaluation
cd frost-evaluation
cargo add frost-ed25519
cargo tree -i frost-ed25519
cargo check --locked
To run the upstream project’s own tests in a separate checkout:
git clone --depth 1 https://github.com/ZcashFoundation/frost.git
cd frost
cargo test --workspace --locked
These commands check dependency resolution and the library’s test suite; they do not audit an application or validate its key-management process.
Before any real signing flow is built, document the trust boundary and test the implementation in an isolated environment. Verify that:
- The key-generation procedure and threshold are explicit, and the group public key is checked by every participant.
- Signers authenticate the session, message, ciphersuite, and complete commitment set before producing a share.
- Nonces and commitments cannot be accidentally reused after an abort, crash, or retry.
- The coordinator validates shares and reports an incomplete session instead of returning a success-shaped result.
- A completed signature verifies with the actual target system’s verifier and encoding.
- Loss of a participant, coordinator outage, and recovery from backups are tested without exposing or reconstructing production shares.
Use the implementation’s test vectors and tests for the selected ciphersuite, then add application-level tests for participant selection, message authorization, retries, and recovery. Do not copy cryptographic formulas into a custom implementation or infer compatibility from a curve name alone. Production deployments should use reviewed libraries, independent key custody where appropriate, authenticated channels, and a recovery plan that accounts for old as well as current shares.
Common Misconceptions
FROST is a standard multisignature wallet
No. FROST is a threshold Schnorr signing protocol. It distributes one signing secret into shares; a conventional multisig arrangement may instead require multiple independent keys and enforce a policy through a script, contract, or verifier.
A coordinator can sign on behalf of the group
No. A coordinator organizes a session but should not be able to create a valid group signature without enough signer contributions. It can still disrupt signing, so coordinator availability and authenticated communication remain operational concerns.
Any group of threshold size can be swapped into an active session
No. Participants commit to a specific signing session. If a selected signer fails after commitments are exchanged, the remaining signers should not treat the session as though the membership had changed; the safe response is to abort and begin a fresh session.
Distributed shares eliminate key risk
No. A threshold of compromised shares can undermine the group, and unsafe key generation, nonce reuse, malicious software, or poor recovery can defeat the intended protections. Threshold cryptography changes how authority is concentrated; it does not remove the need for sound operations.
Related Articles
- Distributed Validator Technology (DVT) Explained
- Multi-Signature Wallets and M-of-N Authorization
- Cross-Chain Bridge Security Considerations
Changelog and Last Updated
- Last updated at initial publication; review when the specification or supported implementations materially change.

