#crypto #polynomial #commitments

no-std winter-fri

Implementation of FRI protocol for the Winterfell STARK prover/verifier

17 unstable releases (7 breaking)

new 0.8.1 Feb 21, 2024
0.7.2 Dec 1, 2023
0.7.0 Oct 23, 2023
0.6.4 May 26, 2023
0.2.0 Aug 24, 2021

#723 in Cryptography

Download history 855/week @ 2023-11-01 814/week @ 2023-11-08 1472/week @ 2023-11-15 1353/week @ 2023-11-22 1719/week @ 2023-11-29 1098/week @ 2023-12-06 1431/week @ 2023-12-13 1027/week @ 2023-12-20 749/week @ 2023-12-27 1237/week @ 2024-01-03 1638/week @ 2024-01-10 1929/week @ 2024-01-17 2529/week @ 2024-01-24 1708/week @ 2024-01-31 1826/week @ 2024-02-07 1776/week @ 2024-02-14

8,074 downloads per month
Used in 13 crates (6 directly)

MIT license

11K SLoC

Winter FRI

This crate contains an implementation of FRI prover and verifier used by the Winterfell STARK prover and verifier.

FRI stands for Fast Reed-Solomon Interactive Oracle Proof of Proximity, and is used in the STARK protocol for low-degree testing. Specifically, given a commitment to a set of evaluations of some function over domain D, the verifier can be convinced that the function is a polynomial of degree at most d, by making a small number of queries to the commitment.


FRI proofs are generated by a FRI prover in two steps:

  1. First, the commit phase of the protocol is executed via build_layers() function. During this phase, the degree of the polynomial is repeatedly reduced by applying a degree-respecting projection, until the size of the domain over which the polynomial is evaluated falls under max_remainder_size parameter. While performing the reduction, the prover writes a set of layer commitments into the ProverChannel. These commitments should be recorded and sent to the verifier as they will be needed during the proof verification procedure.
  2. Then, the query phase of the protocol is executed via build_proof() function. The output of this function is an instance of the FriProof struct. When FRI is executed as a part of the STARK protocol, FRI proof is included into a STARK proof.


FRI proofs are verified by a FriVerifier as follows:

  1. First, a FRI proof needs to be converted into a VerifierChannel. This crate provides a default implementation of the verifier channel, but when FRI proof verification is executed as a part of the larger STARK protocol, STARK verifier handles this conversion.
  2. Then, a FriVerifier should be instantiated (via new() function). This will execute the commit phase of the FRI protocol from the verifier's perspective - i.e., the verifier will read FRI layer commitments from the channel, and generates random values needed for layer folding.
  3. Finally, the query phase of the FRI protocol should be executed via verify() function. Note that query values at the first FRI layer are provided to the verify() function directly. The values at remaining layers, the verifier reads from the specified verifier channel.

Protocol parameters

This crates supports executing FRI protocol with dynamically configurable parameters including:

  • Base STARK field,
  • Extension field,
  • Domain blowup factor,
  • Hash function (used for Merkle tree commitments),
  • Folding factor (used for degree reduction for each FRI layer),
  • Maximum size of the last FRI layer.

Crate features

This crate can be compiled with the following features:

  • std - enabled by default and relies on the Rust standard library.
  • concurrent - implies std and also enables multi-threaded proof generation.
  • no_std - does not rely on the Rust standard library and enables compilation to WebAssembly.

To compile with no_std, disable default features via --no-default-features flag.

Concurrent execution

When this crate is compiled with concurrent feature enabled, FriProver will build FRI layers using multiple threads. The number of threads can be configured via RAYON_NUM_THREADS environment variable, and usually defaults to the number of logical cores on the machine.



This project is MIT licensed.


~52K SLoC