FHE and zero-knowledge proofs
Confidential execution needs two different tools, because two different things have to be hidden. Fully homomorphic encryption (FHE) lets a contract compute on encrypted values without ever decrypting them. A balance, a transfer amount or a reserve can live on-chain as a ciphertext; the contract adds, compares and moves those ciphertexts, and only an authorised party ever sees a plaintext, and only for the result it is entitled to. Fluton uses Fhenix CoFHE for this: a coprocessor network that performs the encrypted arithmetic and signs decryption results, so a contract can act on an encrypted comparison it never saw in the clear. In Fluton’s pool, every token the pool holds is kept in an FHERC20 wrapper, an encrypted ERC-20 whose balances are ciphertexts; the pool’s reserves, its payouts and its liabilities are encrypted state (TOKEN and eTOKEN). Zero-knowledge proofs solve the other problem: proving that an action is valid without revealing which assets it uses. A proof can show that you own some value inside the system, that you are spending it exactly once, and that the amounts balance, while saying nothing about which deposit was yours or how much you hold. Fluton’s Pool uses Groth16 proofs over a note model for this: value is held as private notes, and every state change is one join-split proof that consumes notes and creates new ones. Encryption hides values that a contract must still compute with. Proofs hide the link between an action and the history behind it. Fluton’s architecture puts the two together, so that the chain holds encrypted reserves it can account for, while the ownership and movement of value inside those reserves is proven rather than shown.The execution model
An action in Fluton moves through four stages, and privacy is enforced at each of them rather than bolted onto the result.1
Entry
Value enters a shared, encrypted pool. The deposit is the one public act: it names the
depositor, the token and the amount, and it is screened by a policy check before the pool
accepts it (Deposit screening). From that moment on, the value is
a private note in a shared anonymity set, and the pool’s reserve for that token is an encrypted
balance.
2
Private state
Inside the pool, nothing is public. A note is a commitment on a Merkle tree; its amount, owner
and token are hidden. Every listed token shares one tree and one anonymity set, so a note of one
token is indistinguishable from a note of another until it leaves (Many tokens, one
pool).
3
Confidential execution
An action is a zero-knowledge proof that consumes notes and creates notes. A payment to another
user is a new note addressed to their shielded key, delivered as a ciphertext only they can
open; the chain records neither the amount nor the recipient nor the token (Private
transfers). A relayer can submit the proof and pay the gas, taking
its fee as another private note, so the acting wallet never appears on-chain either (Fees and
referrals).
4
Settlement
When value leaves, only the net result is public: an amount of a token paid to an address, with
no link to the deposit that funded it. The payout itself is an encrypted transfer from the
pool’s reserve, settled through the FHE coprocessor and verified before it is treated as final.
Confidential execution is not mixing
A mixer hides one transfer by pooling it with others of the same size. Fluton’s architecture is built for arbitrary use, not for one transfer shape:
Because value is held as notes and the reserves are encrypted, new confidential actions can be added as new kinds of proof over the same state rather than as new pools.
Application-level privacy
Fluton does not ask users to move to a private chain. The pool is a set of contracts, the encrypted arithmetic runs on Fhenix CoFHE, and the proofs are generated in the user’s own browser; the wallet, the SDK and the relayer are ordinary applications talking to a public network. Privacy is a property of how the application executes, enforced by cryptography at every stage, rather than a property of which chain it runs on. That has three consequences that run through the rest of these docs:- What is public is explicit. The design does not promise that nothing is visible; it states exactly what is, and to whom. What stays public is that list.
- Keys are the user’s. A shielded wallet is derived from one signature of the user’s own wallet, and a read-only view key can be handed to an auditor without handing over the ability to spend (Keys and view keys).
- Trust is named. The coprocessor network, the screening provider, the relayer and the pool’s upgrade key each have a defined role and a defined limit, and the limits are documented rather than hidden (What stays public).