Skip to main content
Public blockchains are transparent by default. Every balance, every transfer and every interaction with a contract is visible to anyone, forever. For a payment that is a leak; for a trading or treasury strategy it is a liability, because what you are about to do can be read, copied or front-run before it settles. Fluton’s answer is to make the execution itself confidential: the action still happens on a public chain, but its amounts, its participants and the state it touches stay hidden from everyone who is not party to it. This page explains the architecture behind that goal, in the form it has today. The pool that implements it is documented in detail from Notes and proofs onwards.

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.
The result is privacy over the whole lifecycle of an action, not only over a transfer. A reader of the chain sees that value entered the pool and that value left it. The connection between the two, everything that happened in between, and the balances that remain are not on the chain in any readable form.

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).
To use the pool, open the wallet at app.fluton.io and read Using the wallet. To build on it, start with the SDK overview.