Fair by proof, not promise.

Prove your sequencer is fair. With math.

Fairseq is the Rust SDK for temporal ordering proofs. Generate cryptographic proof that transactions were sequenced fairly, verifiable by anyone, anchored to trustless time.

example.rs
use fairseq_sdk::{Config, Prover, Transaction};

let config = Config::from_env();
let prover = Prover::new(config).await?;

let transactions = vec![
    Transaction::new("0xabc...", 1704067200),
    Transaction::new("0xdef...", 1704067201),
];

let proof = prover.prove(transactions).await?;
let valid = proof.verify()?;
println!("Valid: {}", valid); // true

Why teams choose FairSeq

The infrastructure layer for provably fair transaction ordering.

Cryptographic Fairness

Zero-knowledge proofs guarantee transaction ordering follows your published rules. Mathematically verifiable, not trust-based.

Developer-First SDK

Native Rust SDK with idiomatic APIs. Drop into your existing sequencer with minimal code changes. Full TypeScript bindings included.

Trade Secret Safe

Keep proprietary ordering policies private while still proving fairness. Share commitments, not your strategies.

MEV Protection

Eliminate front-running and sandwich attacks. Prove your ordering is fair before transactions are finalized.

Technical Specifications

Built for production workloads

Enterprise-grade infrastructure with the performance and reliability your protocol demands.

Proof Generation

  • Sub-second proof generation for batches up to 10K transactions
  • Configurable ordering rules (FIFO, priority-weighted, custom policies)
  • Merkle commitment over transaction ordering with epoch binding
  • O(n) proof construction, O(log n) verification complexity

Verification

  • Constant-time verification independent of batch size
  • Deterministic replay from proof artifacts
  • On-chain Solidity verifier for trustless validation
  • Offline verification for air-gapped audit environments

Integration

  • Native Rust SDK with async/await support
  • REST API with OpenAPI specification
  • Minimal metadata exposure to protect proprietary logic
  • Structured audit logs for compliance workflows
  • Webhook notifications for proof lifecycle events

How it works

Generate cryptographic proofs of fair transaction ordering in three simple steps.

1

Submit Transactions

Send your ordered transaction batch to the Fairseq API with timestamps and metadata.

2

Generate Proof

Our infrastructure generates a cryptographic proof anchored to trustless, verifiable time.

3

Verify Anytime

Anyone can independently verify the proof using our SDK or public verification endpoint.

Built for teams that need provable fairness

L2 sequencer operators
DEX protocol teams
DeFi aggregators
Infrastructure builders
Compliance-minded teams

Ready to prove your fairness?

Get started with the FairSeq SDK today. Free tier available for development and testing.