3SAT Lab logo3SAT Lab

Documentation

3SAT Docs

Public protocol documentation for issuers, solvers, buyers, and developers building with 3SAT. Bounties can settle in USDC or $3SAT. During the initial launch period, verification is operated by the official 3SAT verifier node.

Docs HomeOpen App

Overview

A verifiable SAT answer network

3SAT coordinates three roles around hard SAT instances: issuers post bounties, solvers produce answers, and verifiers attest whether those answers satisfy the original problem.

Search first

Users can check whether a format-normalized instance already has a finalized answer before posting a new bounty.

Settle on-chain

Bounty creation, solver commitments, verifier attestations, and finalization are enforced by smart contracts.

Gate answers

Artifacts are stored off-chain, while access to finalized answer bundles is controlled by protocol rules.

Quickstart

Choose your path

Start from the role that matches what you want to do. The app handles wallet signing and transaction preparation.

I have a SAT problem

Search the answer database first. If no verified answer exists, create a bounty and escrow the reward in USDC or $3SAT.

Open issuer guide

I want to solve bounties

Browse open bounties, run the solver client, and submit SAT assignments or UNSAT proofs through commit and reveal.

Open solver guide

Verifier operations

During the initial launch period, revealed submissions are checked by the official 3SAT verifier node. Third-party verifier onboarding is temporarily paused.

View verifier status

Concepts

Core concepts

These terms appear across the marketplace, role consoles, clients, and API responses.

Bounty

A task posted by an issuer. It links a CNF instance, payment asset, reward, timing windows, verifier quorum, and settlement rules.

Payment asset

The ERC-20 asset selected for a bounty. USDC bounties settle reward, solver payout, verifier reward, bond, and answer access in USDC; $3SAT bounties settle those flows in $3SAT.

Instance file

The SAT problem artifact, represented as a DIMACS CNF file up to 4 MiB and stored through the protocol artifact API.

Solution file

The solver answer artifact. It can be a SAT assignment or an UNSAT proof. Finalized winners can be distributed as a bundle with the original problem and answer artifact.

Matched answer bundle

Format-normalized and variable-renamed SAT matches are rebuilt immediately. Matched UNSAT proofs use an asynchronous transform job and are released only after the target checker accepts them.

Commit reveal

Solvers commit a hash first, then reveal the answer before the post-commit reveal deadline. This prevents simple answer copying during submission.

Verifier quorum

The minimum positive attestations required before a revealed submission can become the accepted candidate. During the initial official-verifier launch phase, issuer bounties use quorum 1.

Finalization

When accept quorum is reached, the keeper can finalize the accepted candidate as soon as the contract reports it as finalizable.

Payments

Supported payment assets

3SAT is a multi-asset protocol. The issuer selects the bounty payment asset, and the same asset is used for that bounty's reward, solver payout, verifier reward pool, solver bond, and answer access fee.

AssetWhere it is usedRouting
USDCIssuer reward escrow, solver payout, verifier reward pool, solver bond, and answer access for USDC bounties.USDC protocol revenue is routed to treasury as company revenue.
$3SATIssuer reward escrow, solver payout, verifier reward pool, solver bond, and answer access for $3SAT bounties.$3SAT routed fees can use the protocol's burn plus treasury routing policy.
$3SAT verifier stakeVerifier eligibility stake is fixed to $3SAT regardless of the bounty payment asset.Verifier stake is collateral for verifier behavior and is separate from bounty reward currency.

Guides

Role guides

Each role has a focused path. You can use the web app directly or automate the same lifecycle through protocol clients and API endpoints.

Issuer

Open
  1. 1Prepare a DIMACS CNF instance.
  2. 2Search the database for an existing verified answer.
  3. 3If no answer exists, upload the instance and configure the bounty.
  4. 4Select USDC or $3SAT as the bounty payment asset.
  5. 5Review reward, solver bond, verifier reward pool, timing windows, and verifier quorum.
  6. 6Approve the selected payment asset and create the bounty with your wallet.
  7. 7After finalization, access the winning answer without paying a separate unlock fee.

Solver

Open
  1. 1Browse the marketplace for open bounties.
  2. 2Download a selected instance or run the solver client.
  3. 3Generate a valid SAT assignment or UNSAT proof artifact.
  4. 4Approve the solver bond in the bounty payment asset.
  5. 5Commit the solution hash while the bounty is open for solving.
  6. 6Reveal the solution before the post-commit reveal deadline.
  7. 7Wait for verifier attestations and keeper finalization. Payout uses the bounty payment asset.

Verifier

Open
  1. 1Verification is currently operated by the official 3SAT verifier node.
  2. 2Third-party and personal verifier node onboarding is temporarily paused.
  3. 3Public verifier client downloads are disabled until verifier onboarding opens.
  4. 4Issuer-created bounties use verifier quorum 1 during this official-verifier launch phase.
  5. 5The official verifier checks SAT assignments and supported UNSAT proofs, then submits attestations on-chain.

Answer access

Open
  1. 1Search by exact CNF, format-normalized CNF, or variable-renamed structure.
  2. 2Review the bounty code, payment asset, answer status, and access price.
  3. 3If you are the issuer, download the finalized answer bundle without a separate unlock payment.
  4. 4If you are a buyer, approve and pay the answer access fee in the bounty payment asset.
  5. 5From search, download a SAT bundle rebuilt for the submitted CNF. For a non-raw UNSAT match, poll the returned transform job until the target checker accepts it and a signed bundle URL becomes available.
  6. 6From bounty detail, download the original finalized bounty bundle.
  7. 7Verify file digests against protocol metadata when integrating programmatically.

Lifecycle

Protocol lifecycle

The network advances a bounty through a small number of public phases. Timing is configured when the bounty is created.

StageActorOutcome
1. SearchIssuer or buyerThe protocol checks exact, format-normalized, and variable-renamed CNF fingerprints for an existing verified answer.
2. Create bountyIssuerThe issuer uploads the instance, selects USDC or $3SAT, sets reward and windows, and creates an on-chain bounty.
3. CommitSolverThe first active solver locks in a hidden solution commitment and starts the reveal deadline.
4. RevealSolverThe solver reveals a SAT assignment or UNSAT proof artifact and digest for verifier review.
5. VerifyOfficial verifierThe official verifier node checks the problem and answer, then attests accept or reject on-chain.
6. FinalizeKeeperThe keeper finalizes accepted candidates, or slashes expired unrevealed submissions so the bounty can reopen.
7. AccessIssuer or buyerAuthorized users download the original finalized bundle, a transformed SAT match, or a checker-accepted transformed UNSAT bundle. Paid access uses the bounty payment asset.

Examples

Developer examples

These examples show the public API shape for common integrations. On-chain actions still require the user's wallet to sign the prepared transaction data.

Standardize CNF before search

Normalize DIMACS formatting and compute both format-normalized and variable-renamed structure fingerprints.

curl -X POST https://3sat.network/api/protocol/sdk/cnf/standardize \
  -H "content-type: application/json" \
  -d '{"text":"p cnf 2 1\n1 -2 0\n"}'

Search the verified answer database

Search exact, format-normalized, and variable-renamed CNF fingerprints to check whether a finalized answer already exists.

curl -X POST https://3sat.network/api/protocol/search \
  -H "content-type: application/json" \
  -d '{"text":"p cnf 2 1\n1 -2 0\n"}'

Resolve a public bounty code

Use the public SAT-... code shown in the marketplace instead of relying on small internal numeric ids.

curl https://3sat.network/api/protocol/sdk/bounties/SAT-XXXX-XXXX-XXXX

Reference

Protocol API overview

The API supports discovery, artifact handling, and transaction preparation. Wallet signatures and on-chain transactions remain under the user's control.

Discovery

GET
/api/protocol/marketplace

List indexed bounties for the marketplace and client discovery.

POST
/api/protocol/search

Search exact, format-normalized, and variable-renamed CNF fingerprints and return answer availability status.

GET
/api/protocol/sdk/bounties/{idOrCode}

Resolve a bounty by public code or internal identifier.

Artifacts

POST
/api/protocol/storage

Upload DIMACS CNF instances up to 4 MiB and metadata up to 25 MiB through controlled server-side multipart storage. Solution artifacts are rejected here and always use the signed direct-upload flow.

POST
/api/protocol/storage/uploads

Reserve a wallet-signed, field-bound, short-lived R2 staging upload for any SAT solution or UNSAT proof.

POST
/api/protocol/storage/uploads/{uploadId}/complete

Finalize a reserved upload only after R2 HEAD metadata, immutable copy, actual byte size, Keccak digest, filename/kind/format bindings, and SAT syntax (when applicable) pass.

GET
/api/protocol/storage

Download authorized artifacts when access checks pass.

GET
/api/protocol/bundles/answer

Download the finalized problem and answer bundle for an authorized user after issuer or paid-access checks.

POST
/api/protocol/bundles/answer

Return a matched SAT/raw-UNSAT ZIP immediately, or HTTP 202 with an opaque poll token for a non-raw UNSAT proof transform job.

POST
/api/protocol/unsat-transform/uploads

Initialize an authorized, time-limited direct R2 upload for matched SAT or UNSAT target CNFs too large for the Vercel request-body limit.

GET
/api/protocol/unsat-transform/jobs/{jobId}

Poll a transform job with its opaque Bearer token. A successful response contains a short-lived signed ZIP download URL and checker report.

Issuer and solver SDK

POST
/api/protocol/sdk/cnf/standardize

Normalize DIMACS CNF content before hashing and searching.

POST
/api/protocol/sdk/issuer/build-metadata

Prepare public bounty metadata from issuer input. Verifier quorum is currently required to be 1.

POST
/api/protocol/sdk/issuer/prepare-create-bounty

Prepare create-bounty transaction data, including the selected payment asset, for wallet signing. Verifier quorum is currently required to be 1.

POST
/api/protocol/sdk/solver/prepare-commit

Validate an opaque artifactId, privately bind it to the commitment, and prepare a solver commit using the bounty's snapshotted bond.

POST
/api/protocol/sdk/solver/prepare-reveal

Prepare reveal transaction data for a committed SAT assignment or UNSAT proof.

Official verifier automation

GET
/api/protocol/verifier/revealed

List revealed submissions inspected by the official verifier automation.

GET
/api/protocol/verifier/artifact

Fetch the problem and answer artifacts needed by authorized verifier automation.

Clients

Download clients

Clients are provided for users who want to run solver or verifier automation outside the web app.

3SAT CLI

Open-source command line client for issuers, buyers, and professional solvers. It supports marketplace discovery, bounty creation dry-runs, answer purchases, solution upload, commit preparation, commit, and reveal.

GitHubIssuer consoleSolver console

Verifier client

Public verifier client downloads are temporarily disabled. During the initial launch period, verification is operated by the official 3SAT verifier node.

WindowsLinux amd64Linux arm64macOS Apple SiliconmacOS Intel

Security

Operational notes

The protocol is designed so users keep control of their wallets and the chain remains the source of truth.

Use dedicated wallets

Run clients with dedicated issuer, solver, or verifier wallets instead of a personal main wallet.

Treat the indexer as cache

Marketplace and search views are cached for speed. Contract state is the authoritative record.

Use generated configs

The app can generate client configuration values so users do not need to hand-edit protocol addresses.

Protect artifacts

Answer access is mediated by API checks and protocol state rather than public bucket URLs.