Signing Round
A signing round is one phase of a multi-step interactive protocol where participants exchange data to produce a signature.
Key Takeaways
- A signing round is one discrete communication phase in a threshold signature or multisignature protocol where every participant sends and receives data before the protocol can advance to the next phase.
- Both FROST and MuSig2 use two signing rounds: the first for nonce exchange, the second for partial signature share generation. Fewer rounds mean lower latency and fewer points where failures can stall the protocol.
- Round count directly affects real-world performance: each additional round adds at least one network round trip, and in wide-area deployments the network delay dominates total signing time.
What Is a Signing Round?
A signing round is a single phase of communication in a multi-party signing protocol. During each round, every participant computes a value locally, broadcasts it to the other participants (or to a coordinator), and waits to receive corresponding values from the rest of the group. The protocol cannot advance to the next round until all required messages from the current round have been collected.
In single-signer Schnorr signatures, signing requires no communication at all: one party holds the private key, computes a nonce, derives the challenge, and produces the signature in a single local operation. When multiple parties share control of a key, however, they must coordinate nonce generation and signature computation through structured rounds of message exchange. The number and content of these rounds define much of the protocol's performance, complexity, and failure characteristics.
The concept applies broadly across cryptographic signing protocols: threshold signatures, multisignatures, and even multi-party computation schemes all describe their interactive phases in terms of rounds.
How It Works
Modern Schnorr-based multi-party signing protocols typically require two rounds. The specific data exchanged in each round varies by protocol, but the general pattern is consistent: a nonce-related round followed by a signature computation round.
Round 1: Nonce Exchange
In the first round, each participant generates fresh cryptographic nonces and shares them (or commitments to them) with the group. These nonces are essential for constructing the aggregate public nonce that appears in the final signature.
In FROST (as specified in RFC 9591), each signer generates a one-time pair of nonces: a hiding nonce and a binding nonce. The signer publishes the corresponding pair of commitments. These nonces must never be reused across signing sessions: reuse can expose a signer's secret key share.
In MuSig2 (specified in BIP-327), each signer generates a pair of nonces and broadcasts them directly (without an initial commitment step). MuSig2's predecessor, MuSig1, required three rounds because it needed a separate commitment round to prevent a rogue-key attack on nonces. MuSig2 eliminated that extra round by using two independent nonces per signer, combined through a binding factor derived from a hash of all nonces.
Round 2: Signature Share Generation
Once all nonce data has been collected, the coordinator (or each participant in a peer-to-peer setup) broadcasts the message to sign along with the full set of nonce commitments. Each signer then:
- Derives the binding factor and computes the aggregate group commitment R
- Computes the Schnorr challenge c = H(R || group_public_key || message)
- Computes their Lagrange interpolation coefficient for the specific signing set (in threshold schemes like FROST)
- Produces a partial signature share combining their nonces, their secret share, and the challenge
In FROST, the signature share takes the form z_i = d_i + ρ_i · e_i + λ_i · s_i · c, where d_i and e_i are the signer's hiding and binding nonces, ρ_i is the binding factor, λ_i is the Lagrange coefficient, s_i is the secret share, and c is the challenge.
Aggregation
After collecting all signature shares from round 2, the coordinator sums them to produce the final aggregate signature (R, z). The coordinator should verify the signature against the group public key before publishing it. If verification fails, the protocol supports identifiable abort: the coordinator can check each share individually to determine which signer produced an invalid share.
Preprocessing: Reducing Interactive Rounds
Both FROST and MuSig2 allow round 1 to be performed before the message is known. Signers can pre-generate and exchange nonces in advance, storing them for later use. When a message arrives, only round 2 (the signature computation) needs to happen interactively. This preprocessing technique effectively reduces the online signing interaction to a single round, though it requires secure storage and careful management of pre-generated nonces.
// Conceptual two-round signing flow
// Round 1: each signer generates and shares nonces
for (const signer of signers) {
const { hidingNonce, bindingNonce } = signer.generateNonces();
const commitment = signer.commitToNonces(hidingNonce, bindingNonce);
coordinator.collect(signer.id, commitment);
}
// Round 2: each signer produces a signature share
const commitmentList = coordinator.getAllCommitments();
for (const signer of signers) {
const share = signer.sign(message, commitmentList);
coordinator.collectShare(signer.id, share);
}
// Aggregation: coordinator combines shares
const signature = coordinator.aggregate(commitmentList, shares);
const valid = verify(signature, groupPublicKey, message);Why Round Count Matters
The number of signing rounds directly determines the minimum latency of the protocol. Each round requires at least one network round trip: every participant must send data, and everyone must wait until all messages arrive before proceeding.
In local or low-latency environments, the difference between two and three rounds may be negligible. But in wide-area deployments where signers are distributed across different regions or even countries, network latency dominates total signing time. Research on threshold ECDSA protocols has shown that a 3-member committee takes roughly 0.8 seconds at 100ms round-trip latency, while a 15-member committee can take over 4 seconds: much of that time is spent waiting for network messages, not computing.
For systems like Spark that use threshold signing for real-time transaction processing, minimizing round count is critical. A two-round protocol with preprocessing can achieve sub-second signing even with geographically distributed signers, while a three-round protocol under the same conditions would add 50% more latency.
Round Count Across Protocols
| Protocol | Rounds | With Preprocessing | Notes |
|---|---|---|---|
| FROST (RFC 9591) | 2 | 1 | Threshold Schnorr; supports identifiable abort |
| MuSig2 (BIP-327) | 2 | 1 | n-of-n multisig; no commitment round needed |
| MuSig1 | 3 | 2 | Required extra commitment round for security |
| Traditional Schnorr threshold | 3+ | Varies | Older schemes traded rounds for simpler security proofs |
Use Cases
Threshold Custody and Wallets
Threshold signature wallets distribute key control across multiple parties. Each signing operation requires the participants to complete the full round sequence. In custody setups where signers may be on different continents or using air-gapped devices, the round count determines how quickly transactions can be authorized. Two-round protocols like FROST keep this practical for cooperative signing workflows even under high-latency conditions.
Bitcoin Layer 2 Protocols
Layer 2 systems that rely on multi-party signing for state transitions are directly affected by round count. Spark, for example, uses FROST-based threshold signing to process transactions off-chain. Each transaction requires a signing round sequence between the user and the Spark operators. The two-round design keeps transaction latency low enough for real-time payments while maintaining the security of threshold control. See the Spark FROST signing performance analysis for measured benchmarks.
Distributed Key Generation Ceremonies
While distributed key generation (DKG) is a separate process from signing, it also involves rounds of communication. The round structure of the DKG ceremony determines setup cost: a FROST DKG typically requires two to three rounds to establish key shares. Once shares are established, the two-round signing protocol runs independently for each transaction.
Risks and Considerations
Participant Availability
Every round requires all participating signers to respond before the protocol advances. If any signer goes offline, crashes, or experiences network partition during a round, the entire signing session stalls. In a two-round protocol, there are two points where this can happen. A three-round protocol has three such failure windows.
The ROAST protocol addresses this by wrapping FROST in a session management layer that runs multiple signing attempts in parallel. If a signer fails to respond in one session, ROAST can start a new session with a different subset of signers. This guarantees progress as long as enough honest signers are available, though it adds coordination overhead.
Nonce Management
The security of both rounds depends critically on proper nonce handling. Each signing session must use fresh, unpredictable nonces. Reusing a nonce across two different signing sessions can allow an attacker to extract the signer's secret key share through simple algebra: given two signatures with the same nonce, the secret share can be computed directly.
When using preprocessing (pre-generating round 1 nonces), the stored nonce state must be protected against loss and duplication. If a system crashes and replays a stored nonce, or if a backup restore causes nonce reuse, the key share is compromised. RFC 9591 dedicates a specific section (7.3) to nonce reuse attacks and mitigations.
Coordinator Trust
Many multi-party signing protocols use a coordinator to collect round messages and broadcast them. The coordinator sees all commitments and signature shares but cannot forge signatures without possessing key shares. However, a malicious coordinator could selectively withhold messages to stall the protocol, relay incorrect commitment lists to cause aborts, or attempt to correlate signing activity with specific signers.
These risks are protocol-level, not round-specific, but they compound with round count: more rounds give a malicious coordinator more opportunities to interfere.
Network Latency and Ordering
Signing rounds assume a synchronous communication model within each round: all messages from round N must arrive before round N+1 begins. In practice, network jitter, packet loss, and variable latency mean that the slowest participant determines the round duration. For protocols with a signing quorum of many participants, tail latency (the delay caused by the slowest responder) can significantly exceed the median response time.
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.