Skip to content
z0r0zPublic

About

smart contracts on bitcoin

Resources

Security policy

Stars

47 stars

Watchers

2 watching

Forks

Latest commit

 

History

6,157 Commits

Folders and files

Repository files navigation

tacit

tacit

Tokenization and confidential DeFi on Bitcoin, with a zero-knowledge bridge to a confidential zone on Ethereum.

Live on Ethereum mainnet since 2026-09-18 (contracts and addresses). The first Bitcoin-native AMM pool, founded directly on Bitcoin with no Ethereum contract, is live in the indexer as of 2026-09-25 (pool and reserves). The Tacit chain, a zk-rollup for private TAC payments settled on Ethereum, is live on mainnet (contracts).

Tacit is a Bitcoin metaprotocol. Assets are issued and transferred in Taproot envelopes. Amounts are hidden by Pedersen commitments and range proofs, and any indexer running the spec reaches the same state from the chain alone.

The same confidential note also lives in an immutable pool on Ethereum. There it can be:

  • swapped, lent against, farmed or paid privately;
  • relayed without gas;
  • moved back to Bitcoin.

SP1 zero-knowledge proofs carry state between the two chains in both directions. No multisig, federation or attestor set signs a bridge message.


What it does

On Bitcoin

  • Issue assets with hidden or fair-launch supply (T_CETCH, T_PETCH/T_PMINT). The issuer can publish its supply opening so anyone can audit it. TAC, the native asset, was issued with T_CETCH and a zero mint authority, so its supply is fixed (genesis, supply and its Ethereum ERC-20).
  • Transfer confidentially. Amounts are hidden, conservation is proven by a kernel signature, and range proofs are Bulletproofs+. Recipients recover credits from their key alone.
  • Trade atomically.
    • Atomic offers: sell an asset directly for BTC in one transaction. A maker lists a lot, any taker completes it.
    • Bids that a watchtower fills while the buyer is offline, matched off-chain and settled atomically on the first fill.
    • A native AMM: per-trade swaps, routes over up to four pools, and batch clearing at a uniform price.
    • LP farms.
  • Lock BTC for cBTC. A self-custody lock on Bitcoin backs fungible cBTC in the pool.
  • Send value-free calls. A Bitcoin-signed message can authorize an Ethereum call, and Ethereum can send messages back.

In the confidential pool (Ethereum)

  • Wrap ETH or ERC-20s into notes, transfer privately, and unwrap to any address.
  • Trade on a confidential AMM: swaps, routes, uniform-price batches and liquidity. OTC trades and buyer-offline bids (OP_BID, client in confidential-bid.js) also run here.
  • Pay by stealth: the recipient gets a one-time key, claims it, and the sender can refund if unclaimed.
  • Use adaptor locks for atomic swaps against the other chain.
  • Borrow cUSD against cBTC collateral. Mint cBTC against reflected BTC locks.
  • Earn farm rewards on LP positions, paid in wTAC (a 1:1 TAC wrapper).
  • Relay any op without gas, with the relayer's fee bound inside the proof. Anyone can also prove and settle their own ops.

On the Tacit chain (Ethereum)

  • Hold and send TAC privately. Each payment is proved on the payer's device, and each block is one SP1 proof checked on Ethereum, which keeps the block's data.
  • Shield TAC from an Ethereum wallet, with no ETH needed. Withdraw to any address, or hop into the confidential pool.
  • Notes count shares of the chain's pool, and the fees that stay in it raise every share's worth.
  • Leaders lock 1,000 TAC for a seat and take turns. A forced queue on Ethereum takes any spend no leader takes.

Between the chains

  • Bitcoin → Ethereum. A full-proof-of-work header relay feeds an SP1 guest. The guest folds Tacit envelopes into roots that the pool accepts after 24 confirmations.
  • Bridge burn. Burn a note on Bitcoin in a standard transaction, paying only BTC, and the pool mints it once, with the relayer's fee taken from the note (bridgeBurnToPool, then bridgeMint). A Bitcoin-only user never needs ETH; only minting cBTC does, for its escrow.
  • Fast lane. A reflected Bitcoin note bound to the pool (T_CXFER_BOUND) is spent directly on Ethereum, with no bridge burn. The proof shows the note is not already spent on Bitcoin, and reflection later retires it there, so it can never be spent twice. Proven live: 0x548d52cb…4940fd0c84 and again at 0x9811b18e…56b3865f.
  • Ethereum → Bitcoin. An SP1 light-client guest proves pool storage. The Bitcoin guest verifies that proof recursively, so crossed-out notes are re-minted on Bitcoin.
  • One note, two chains. The note commitment is the same secp256k1 Pedersen commitment on both sides.

How it is built

            Bitcoin L1                                  Ethereum L1
  ┌───────────────────────────┐              ┌────────────────────────────────┐
  │ Taproot envelopes         │  headers +   │ BitcoinLightRelay (full PoW)   │
  │  issue · transfer · trade │  SP1 proof   │ ConfidentialPool (immutable)   │
  │  AMM · farms · cBTC locks │ ───────────▶ │  note tree · nullifiers        │
  │  bridge burns · calls     │              │  settle(SP1 proof)             │
  │                           │  SP1 light-  │  AMM · CDP · farms · stealth   │
  │ indexers (dapp, worker)   │ ◀─────────── │ CollateralEngine · FarmManager │
  └───────────────────────────┘ client proof └────────────────────────────────┘
        secp256k1 Pedersen · BP+ range proofs · Schnorr kernels · keccak IMTs

Three layers, not two. The Bitcoin metaprotocol and the Ethereum confidential pool are each a full, independently-derivable ledger; reflection is the zero-knowledge layer that reconciles them, not a custody bridge. Bitcoin-homed notes carry their own leaf and nullifier, derived from the note's actual Bitcoin output key, so Bitcoin-side state stands on its own before any reflection proof runs.

Three SP1 programs:

  • the settle guest, which proves pool ops;
  • the Bitcoin reflection guest, which proves Bitcoin blocks;
  • the Ethereum reflection guest, which proves pool storage via sp1-helios.

Each is pinned by ELF hash to an immutable verifying key, and each rebuilds byte for byte.

The Tacit chain adds a fourth: the block program (contracts/sp1/confidential/tacit-block), which checks a whole block of the payers' Halo2 spend proofs in one SP1 run. TacitBlocks verifies each block's Groth16 proof under its immutable BLOCK_VKEY, holds the chain's TAC and publishes the block's data, and TacitSeats decides whose turn it is to land. Spec: docs/TACIT-BLOCKS.md.

Ceremonies. The transparent stack needs no trusted setup. Two finalized ceremonies supply Groth16 keys for circuits that are expensive to express otherwise:

  • the AMM ceremony, whose amm_swap_batch key is compiled into both guests for blind batch swaps (T_SWAP_BATCH on Bitcoin, OP_SWAP_BLIND in the pool);
  • the mixer ceremony, for the legacy fixed-denomination mixer on Bitcoin.

Details are in SPEC §2.8; every artifact, with its CID and hash, is in docs/CEREMONY.md.

Room for Bitcoin covenants. Some op codes and opcode bytes are held for constructions Bitcoin cannot yet enforce. The main one is covenant-locked cBTC with no escrow. The others are on-chain bid escrow and fractional BTC slots. See SPEC §10.

Secret Sats: special-purpose pools

Secret Sats (paper) is a Bitcoin-native shielded pool for private payments. It complements the confidential pool; it does not replace it.

  • General pool, general prover. The confidential pool runs open-ended DeFi and the bridge, so it uses the SP1 zkVM: one program for many ops, one immutable verifier, and batched proofs whose cost is shared. System-level work stays there: reflection, batch settlement, cross-chain facts.
  • Special-purpose pools, fixed circuits. A pool that does one thing, such as private payments, uses a small fixed circuit. Users prove their own spends on their device in seconds, so no prover sees their amounts and nobody pays for proving. Indexers verify each proof locally against Bitcoin data, and relayers post spends for a fee paid inside the pool, so a sender needs no Bitcoin wallet.
  • The Bitcoin pool. It carries Tacit assets, not BTC, and TAC is the first asset the dapp offers into it. Shield and exit connect to ordinary Tacit notes through a cross-curve proof and a range proof. Joining is one step (buy-and-shield) and so is leaving (exit-to-sats, with the maker's payout bound into the signed spend). It is live on mainnet, flagged experimental. Its proof system is Halo2 with KZG over the Hermez setup already pinned, so it needs no new ceremony.
  • The EVM pool. The same keys, notes and address, for ETH on Ethereum, Base and Robinhood Chain, and for ERC-20s such as USDC and USDT on Ethereum. One Groth16 circuit (two notes in, two out) from a public ceremony, proved in the browser; the contract never hashes, so a private transfer costs about 340k gas. A standing private address takes ETH from any wallet or exchange, and a withdrawal can run a swap, a bridge or a move into a V1 note in the same transaction.
  • Sats in and out. Atomic swaps move sats in and out with no custodian. A BitVM peg and, once Bitcoin allows them, covenants can back the same pool unchanged. Secret Sats Join mixes real sats in an equal-amount join to silent-payment outputs, with no coordinator and no custody.

Try it on signet at tacit.finance/sats. There, cBTC is a test token: a regular Tacit etch (17619b4c…66c5, ticker cBTC, 8 decimals, fixed supply, no BTC behind it). A faucet keeps small lots listed as pre-authorized sales at 1,000 signet sats each, so getting test cBTC is itself an atomic swap, and it also drips signet sats for fees. Pool spends are proved in the browser.

Seen on signet: a buy-and-shield, a relayed private payment and an exit to sats, each proved on the payer's device, and a silent payment found through the tweak index with no txid shared, and an eight-wallet join that mixes plain sats into equal outputs.

Private ETH is live on Ethereum, Base and Robinhood Chain at the same addresses: pool 0x000000c2A20657CE25f2Ba99737933D031AFBEE9, router 0x0000006C96Afa6f1cD4DF8FE19bc0d8B6A6Cd7B5, verifier 0x000000b1c0e84CEc8AdF8278B90c4d6400DfB153. Its proving key comes from a public ceremony: 176 contributions, sealed with Bitcoin block 968840 (key hash 43d11e6e…5757). Use it at anon.wei.limo, at tacit.finance/pay/eth, or from the ETH tab at tacit.finance/sats. Integration: docs/EVM-POOL.md; deployments: contracts/deployments/evm-pool.json.

Specification: SPEC §3.10. Design: pool, security, BTC boundary, join.

Privacy and trust

  • Hidden: amounts, which owned note a pool spend consumes, and stealth recipients. Prover-blind batches (OP_SWAP_BLIND) also hide trade sizes from the SP1 prover.
  • Public: Bitcoin addresses and the transaction graph, asset ids on Bitcoin, the pool's deposit and withdrawal boundary, AMM reserves and their changes, and CDP position amounts. A position's owner stays unlinkable.
  • You trust: Bitcoin and Ethereum consensus, SP1 and Groth16 soundness, the sp1-helios sync committee, and the ceremonies (only for the circuits that use them).
    • cUSD and the cBTC escrow rely on price feeds (BTC/USD, and BTC per wstETH).
    • cBTC is secured economically, by the locker's wstETH escrow (at least the engine's escrow ratio, 1.5× today).
    • The periphery (CollateralEngine, FarmManager) is governed by a 2-of-5 ops multisig with a built-in one-hour delay, within on-chain bounds.
    • Walk-away bids on Bitcoin rely on a watchtower holding a capped, dedicated key.
  • You don't trust: relayers, the hosted API or IPFS gateways. The pool, its guests and their keys cannot be changed, and every balance recovers from your key plus chain data.
  • You depend on someone proving, for liveness only. Proofs are built from public chain data, so anyone can run them. If nobody does, reflected state pauses rather than going wrong, and Ethereum-side exits still work with your own proof. Nobody can take or forge a balance either way.

The protocol evolves by deploying successor pools that users opt into by exiting one pool and entering the next. A retired pool keeps every exit open (SPEC §8).

Run the dapp

The dapp is static files: the front page dapp/index.html, a directory for each page (dapp/tac/, dapp/pay/, dapp/vault/, …), the protocol core dapp/tacit.js and a vendored crypto bundle.

cd dapp && python3 -m http.server 8000     # http://localhost:8000

Pin dapp/ to IPFS or any static host. Install the build tools once with (cd build && npm install) && npm install. After an edit, npm run build refreshes the pages' cache tokens, CSP hashes and shared header and footer, and prints the SRI hashes; npm run build:vendor also rebuilds the vendored bundle.

Sign in with an Ethereum wallet, a passkey, a Bitcoin wallet or an imported key. A wallet identity comes from one deterministic signature over the Tacit identity message, the same in every Tacit app, so reconnecting anywhere restores it. Anyone holding that signature controls the funds, so sign it only in a Tacit app you trust.

To check recovery, import your key in a fresh browser and rescan: every balance and position should return from chain data alone.

Repository

dapp/            the app: protocol core (tacit.js), pool client (confidential-*.js), circuits, ceremony bundle
contracts/       Solidity (src/, script/, test/) and SP1 guests (sp1/confidential, sp1/eth-reflection),
                 the Tacit chain's block program among them (sp1/confidential/tacit-block)
worker/          indexer + API (served by server/ on Node); reads Bitcoin from public Esplora endpoints
                 with fallbacks; never proves, never holds funds
worker-relay/    hosted relay: settle, reflection, header relay, monitoring, EVM pool keepers
tacit-leader/    the Tacit chain's leader: follows TacitBlocks, builds, proves and lands blocks
tests/           cross-implementation vectors and test suites
tools/ scripts/  operational and verification tools
docs/            integrator guides: build a dapp, deployments, ceremony artifacts, farms, airdrop, recovery,
                 reproducible builds, live verification, the Tacit chain's spec
audit/           security reviews
whitepaper/      the papers: the Tacit whitepaper (.md, .tex, .pdf) and Secret Sats (.tex, .pdf)

Brand assets

32×32 SVG marks, each the same file already used on-chain or in a token listing — published as static assets under dapp/, so they deploy with the app and resolve at a stable URL for external submissions (exchange listings, token-logo registries, etc.).

Asset Live URL Source in repo
TAC tacit.finance/brand/logo.svg assets/tac-onchain.svg — mirrors the mark inlined on-chain in TAC's token.list.wei listing
tETH / cETH tacit.finance/brand/teth.svg contracts/teth-icon.svg
cBTC tacit.finance/brand/cbtc.svg contracts/tokenlist-drafts/cbtc-zk-icon.svg
cUSD tacit.finance/brand/cusd.svg contracts/tokenlist-drafts/cusd-zk-icon.svg
Tacit (protocol mark, 48×48) tacit.finance/brand/mark.svg assets/tacit-mark.svg

TAC

TAC is the protocol's native token: 21M fixed supply, issued on Bitcoin, bridged to Ethereum as an ERC-20. Verify the supply yourself, from Bitcoin and IPFS, at tacit.finance/verify.html — no server or indexer trusted, the page recomputes it in your browser. Holding TAC boosts points and lowers the dapp's private exit fee. TAC collected as relay fees is never sold, and a tenth of the relay's fee income funds TacBuyback, which buys TAC on the open market for the protocol reserve.

TAC also governs: holders vote on proposals that the ops multisig carries out, either privately by proving a Bitcoin TAC balance tier or in the open with an Ethereum wallet's exact ERC-20 balance, weighed at a snapshot taken when each proposal opens. Proposing, voting and the reserve's flows are in docs/TAC.md.

Points and farms

A time-limited launch program, not a protocol feature.

  • Points. 100,000 TAC is paid out over 90 days, 2026-09-23 through 2026-12-21 (UTC): each day's pot, up to 1,111 TAC, is split by that day's points. From 2026-10-03 (UTC) a day pays at most 0.03 TAC per point, so a day with little activity pays out less than the full amount. Points go to the address that sent each transaction:

    • wrapping ETH into the confidential pool: 1,250 per ETH;
    • depositing ETH into the EVM pool on Ethereum, Base or Robinhood Chain: 1,000 per ETH;
    • swapping ETH through zRouter or zSwap, and betting ETH on zSwap: 1,000 per ETH; creating a zSwap market: 50;
    • registering a .wei name: 1,000 per ETH of the fee;
    • posting wstETH toward a cBTC mint: 1,000 per wstETH;
    • minting cUSD from your own account: 2 per dollar (a loan the relay sends earns nothing).

    Every activity gets an early bonus of up to 5x that decays as more of that same activity accrues, not a one-time reward for whoever is first. Wrapping ETH from an address that has ever received a Privacy Pools withdrawal earns an extra 1.2x. Holding 100 / 1,000 / 10,000 public TAC at the sending address through the previous 24 hours multiplies its points by 1.25x / 1.5x / 2x (docs/TAC.md). From 2026-10-04 (UTC) an address's points for the day are raised by 25% for each other kind of activity it has had in the past 7 days (private ETH, swaps, borrowing, names and markets; up to +50%, and a kind counts once it has earned 25 points that week) and by another 25% if it was active on more than one of those days, 1.75x at most. A cBTC bond counts for its day only if cBTC has been minted against it and it is still posted when the day settles, shortly after the day ends; and a bond on a Bitcoin lock also earns a flat 500 points per wstETH for each further day it stays posted, up to the escrow the lock needs and credited when the day settles (no early bonus or holder boost, and counted as activity for the week's multiplier). zSwap activity counts from launch only, with no retroactive credit. Claims run through PointsDistributor.

  • Farms. LP positions in the confidential pool earn wTAC from FarmManager — 99,700 TAC over 90 days, 2026-09-20 to 2026-12-19 (UTC), split across three pools (docs/FARMS.md). A public TAC/ETH farm also runs on PrecisionFarm, paying ~554 TAC/day through 2026-12-19.

Credits

  • Pedersen commitments and Mimblewimble kernels: Pedersen; Jedusor; Poelstra.
  • Bulletproofs: Bünz, Bootle, Boneh, Poelstra, Wuille, Maxwell. Bulletproofs+: Chung et al.
  • BIP-340/341: Wuille, Nick, Ruffing, Towns.
  • SP1 and sp1-helios: Succinct. Groth16: Groth.
  • The Tornado-style mixer circuit is adapted from Tornado Cash.
  • Uniform-price batch clearing follows Walras, Gnosis Protocol and Penumbra.
  • The indexer-validated metaprotocol pattern comes from Ordinals and Runes.
  • Libraries: @noble/secp256k1, @noble/hashes, snarkjs, circomlib, Solady.

License

See LICENSE.

About

smart contracts on bitcoin

Resources

Security policy

Stars

47 stars

Watchers

2 watching

Forks

Releases

Packages

Contributors

Languages