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
Look up exact file hashes before posting a bounty. Small instances also support resource-bounded normalized matching.
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 guideI want to solve bounties
Browse open bounties, run the solver client, and submit SAT assignments or UNSAT proofs through commit and reveal.
Open solver guideVerifier 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 statusConcepts
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: DIMACS CNF up to 256 MiB, streamed directly to R2 and validated by the background artifact worker before use.
Solution file
A SAT assignment up to 256 MiB or an UNSAT proof up to 1 GiB. Upload readiness checks bytes and syntax; mathematical proof verification happens after reveal.
Matched answer bundle
Within the small-file/count matching budget, SAT answers can be rebuilt and UNSAT proofs transformed and checker-approved. Large raw-exact answers use direct file downloads, not variable-renaming transforms.
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.
Artifact profile
Large files and operational limits
File-size ceilings are not guarantees of solving or verification time. Variable, clause, line, memory, disk and checker-time budgets still apply.
Uploads use 8 MiB parts sent directly to private R2 storage. The website receives small control requests, and a separate Artifact Worker validates size, hash and CNF syntax before returning ready. This off-chain upload signature adds no gas transaction.
The streaming CNF profile allows up to 5,000,000 variables, 20,000,000 clauses, 100,000,000 literal occurrences, 25,000,000 physical lines, 1 MiB per physical line and 5,000,000 literals per clause.
Large instances use raw-only indexing: exact file-hash search, solving and original-answer access remain available. Interactive non-raw answer mapping is limited to 3.5 MiB per CNF, 50,000 variables, 100,000 clauses and 300,000 literal occurrences; large variable-renaming transformations are not supported.
Original answers use a signed manifest with direct R2 download links and expected hashes. CLI verifies streamed downloads and builds a ZIP locally. Browser direct downloads do not claim automatic byte verification.
Verifier validation concurrency remains two; memory-heavy native checks share a bounded execution slot. Resource exhaustion or checker timeout defers work rather than rejecting an answer. A 4 GB host cannot be assumed to verify every permitted proof within its deadline.
Interrupted Solver uploads preserve receipts and solved proof files until commit recovery state is saved or the bounty is authoritatively closed. Disposable scratch and upload staging are cleaned separately; never delete live evidence or commit/reveal recovery files as ordinary cache.
Operators must deploy the matching website, clients, verifier, Transform Worker and additional Artifact Worker together. Existing environment files keep their old explicit limits until updated; Keeper and deployed contracts do not change.
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.
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- 1Prepare a DIMACS CNF instance.
- 2Search the database for an existing verified answer.
- 3If no answer exists, upload the instance directly to R2 and wait for background validation to report ready before creating the bounty.
- 4Select USDC or $3SAT as the bounty payment asset.
- 5Review reward, solver bond, verifier reward pool, timing windows, and verifier quorum.
- 6Approve the selected payment asset and create the bounty with your wallet.
- 7After finalization, access the winning answer without paying a separate unlock fee.
Solver
Open- 1Browse the marketplace for open bounties.
- 2Download a selected instance or run the solver client.
- 3Generate a valid SAT assignment or UNSAT proof artifact.
- 4Upload with CLI 0.1.1 or Solver 0.2.0 and wait for ready before preparing a commit; keep upload receipts and pending proof files when resuming.
- 5Approve the solver bond in the bounty payment asset.
- 6Commit the solution hash while the bounty is open for solving.
- 7Reveal the solution before the post-commit reveal deadline.
- 8Wait for verifier attestations and keeper finalization. Payout uses the bounty payment asset.
Verifier
Open- 1Verification is currently operated by the official 3SAT verifier node.
- 2Third-party and personal verifier node onboarding is temporarily paused.
- 3Public verifier client downloads are disabled until verifier onboarding opens.
- 4Issuer-created bounties use verifier quorum 1 during this official-verifier launch phase.
- 5The official verifier checks SAT assignments and supported UNSAT proofs, then submits attestations on-chain.
Answer access
Open- 1Search large CNFs by exact file hash; format-normalized and variable-renamed searches have separate small-file/count limits.
- 2Review the bounty code, payment asset, answer status, and access price.
- 3If you are the issuer, download the finalized answer bundle without a separate unlock payment.
- 4If you are a buyer, approve and pay the answer access fee in the bounty payment asset.
- 5For a supported small non-raw match, download a rebuilt SAT bundle or poll the UNSAT transform job until the target checker accepts the proof.
- 6For original or large raw-exact answers, use the authorized manifest's direct problem and answer download links; CLI verifies both files and builds the ZIP locally.
- 7Browser direct links show expected hashes but do not verify downloaded bytes. Verify digests yourself or use CLI.
Lifecycle
Protocol lifecycle
The network advances a bounty through a small number of public phases. Timing is configured when the bounty is created.
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
For small inputs within the interactive budget, normalize DIMACS formatting and compute normalized fingerprints. Use CLI streaming normalization for large files.
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-XXXXReference
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
/api/protocol/marketplaceList indexed bounties with limit/offset pagination. The dashboard sets excludeClosedNoSubmission=1 to hide finalized bounties with zero submissions and no verified answer; totals count matching records. Filtered pages return nextBeforeBountyId when more remain: pass it as beforeBountyId instead of offset to continue without skipping tasks closed between pages. Without the filter, historical records remain available to clients and the bounty console.
/api/protocol/searchSearch exact file hashes up to the CNF ceiling. Small inputs additionally support resource-bounded normalized/variable-renamed fingerprints; large inputs send mode: raw-only.
/api/protocol/sdk/bounties/{idOrCode}Resolve a bounty by public code or internal identifier.
Artifacts
/api/protocol/storageLegacy small inline instance/metadata upload. New clients use the signed artifact-uploads API for CNF up to 256 MiB and UNSAT proofs up to 1 GiB.
/api/protocol/storage/artifact-uploadsReserve an authenticated 8 MiB-part R2 upload. The file body never crosses a Vercel function.
/api/protocol/storage/artifact-uploads/{uploadId}Get part URLs, complete, poll background validation, or abort an unfinished upload. Do not create a bounty/commit until status is ready.
/api/protocol/storage/uploadsLegacy small-solution upload. Large uploads receive an upgrade instruction; use artifact-uploads for new integrations.
/api/protocol/storage/uploads/{uploadId}/completeFinalize 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.
/api/protocol/storageDownload authorized artifacts when access checks pass.
/api/protocol/bundles/answerUse ?format=manifest for authorized direct R2 file URLs with hashes and sizes; CLI verifies files and builds ZIP locally. Inline ZIP is limited to small answers.
/api/protocol/bundles/answerRaw-exact queryDigest requests return a signed download manifest. Supported small matched answers return a size-bounded ZIP or HTTP 202 for checker-validated UNSAT transformation.
/api/protocol/unsat-transform/uploadsRetained legacy target-staging endpoint. Its upload ceiling does not lift the interactive non-raw matching budget; large raw-exact clients use a manifest without uploading another target.
/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
/api/protocol/sdk/cnf/standardizeNormalize small DIMACS CNF content within the 3.5 MiB and structural-count budget. CLI streams larger format-only normalization without claiming structural matching.
/api/protocol/sdk/issuer/build-metadataPrepare public bounty metadata from issuer input. Verifier quorum is currently required to be 1.
/api/protocol/sdk/issuer/prepare-create-bountyPrepare create-bounty transaction data, including the selected payment asset, for wallet signing. Verifier quorum is currently required to be 1.
/api/protocol/sdk/solver/prepare-commitValidate an opaque artifactId, privately bind it to the commitment, and prepare a solver commit using the bounty's snapshotted bond.
/api/protocol/sdk/solver/prepare-revealPrepare reveal transaction data for a committed SAT assignment or UNSAT proof.
Official verifier automation
/api/protocol/storage/artifact-workerOperator-only background upload validation: claim, renew, complete or fail a leased job using the worker Bearer token. This service does not attest on-chain.
/api/protocol/verifier/revealedReturn one explicit chain-derived bounty/submission pair and its artifact availability to authorized official verifier automation.
/api/protocol/verifier/artifactFetch 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
CLI 0.1.1 adds streaming large-file uploads, resumable receipts, verified direct downloads and local ZIP creation. Upgrade with python -m pip install --upgrade 3sat after the release is available on PyPI.
Solver client
Solver 0.2.0 packages support 256 MiB CNF, 1 GiB proofs and resumable uploads without repeating completed solving work. Install Node.js 22 LTS or newer before using the matching platform package.
Verifier client
Public verifier client downloads are temporarily disabled. During the initial launch period, verification is operated by the official 3SAT verifier node.
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.