ciFHEr

Track: Solana

PT-BR:

ciFHEr - Token Confidencial na Solana com Criptografia Homomórfica

Wrapper de privacidade totalmente colateralizado para SOL, onde saldos e valores de transferência são armazenados on-chain como ciphertexts FHE. Validadores, block explorers e qualquer observador da rede veem apenas bytes criptografados, sem nenhum valor em texto claro.

Detalhamento:

ciFHEr resolve um problema fundamental das blockchains públicas: toda transação na Solana é visível para qualquer pessoa. Saldo, para quem você transferiu, quanto você trocou — tudo exposto em um block explorer. Para usuários comuns isso é desconfortável. Para instituições e fundos movimentando capital relevante, é inviável.

Nossa solução armazena saldos e valores de transferência como ciphertexts FHE diretamente na blockchain. Um cifherSOL equivale a um SOL bloqueado em escrow. Não existem zero-knowledge proofs, nenhuma cerimônia de setup confiável, nenhum commitment substituindo o dado real. Os ciphertexts on-chain são os saldos.

A criptografia é feita com tfhe-rs (Rust, v0.7). Uma ServerKey permite aritmética genuína sobre ciphertexts: quando você transfere tokens, o worker computa:

- newSenderBalance = fheSub(senderCt, amountCt)

- newRecipientBalance = fheAdd(recipientCt, amountCt)

Os saldos do remetente e do destinatário nunca são descriptografados durante a operação. A subtração e a adição acontecem inteiramente no espaço cifrado. Apenas o resultado final é descriptografado para ser recomprimido em um ciphertext compacto antes de ser escrito de volta na chain. Em versões futuras, essa etapa de descriptografia será eliminada com evaluation keys compartilhadas entre uma rede descentralizada de operadores, de modo que nenhum nó individual veja um valor em texto claro.

ciFHEr conta com dois programas Anchor na devnet da Solana:

- confidential-token: ciclo de vida do token confidencial — mint de cifherSOL bloqueando SOL em escrow, transferências com atualização homomórfica de saldos e burn para resgatar SOL

- confidential-swap: pool de swap confidencial onde usuários trocam SOL por cifherSOL sem revelar o valor trocado, pois a reserva do pool é ela mesma um ciphertext FHE atualizado homomorficamente a cada operação

Programas Deployados na Solana Devnet:

- confidential-token: 86C1FkYaVUjV2wyWmRMrnGhXGNNpnH9aFLAJQKkAtf6u

- confidential-swap: A2vktybx3Nahc7THvSckeVioTobVkHNEXM5ZteGkoLDK

Tecnologias: Rust, tfhe-rs 0.7, Anchor, Solana, Node.js, TypeScript, React.

----------------------------------------------------------------

Sobre esse projeto e planos futuros:

ciFHEr demonstra que privacidade real em blockchains públicas é possível hoje, sem sacrificar a auditabilidade do protocolo. O modelo atual com operador único é o ponto de partida honesto para um sistema que, na próxima iteração, distribui a chave de descriptografia entre múltiplos nós independentes via threshold FHE.

À medida que o sistema amadurece, o SOL bloqueado no vault passa a gerar yield via liquid staking, transformando o colateral ocioso em receita passiva para o protocolo. Um token de governança alinha os incentivos dos operadores e abre a participação da comunidade nas decisões do protocolo.

----------------------------------------------------------------

Roadmap de Curto Prazo:

Threshold FHE:

- Substituir o operador único por uma rede de nós independentes

- Chave de descriptografia dividida entre múltiplos operadores via threshold FHE

- Nenhum nó individual consegue ler saldos de usuários

Liquid Staking do Vault:

- Depositar SOL do vault em Marinade ou Jito, gerando ~7-8% APY

- Resgates automáticos via DEX liquidity sem fila de unstaking

- Receita passiva proporcional ao total bloqueado no protocolo

Token de Protocolo:

- Alinhamento de incentivos para operadores da rede threshold

- Participação da comunidade na governança

- Operadores ganham share das taxas do protocolo

----------------------------------------------------------------

Desafios:

O maior desafio técnico foi encaixar ciphertexts de 16 KB no modelo de contas da Solana. Transações suportam no máximo 1.232 bytes, contas só podem crescer 10 KB por transação, e o heap do BPF tem 32 KB — um Vec de 16 KB dobra de capacidade no crescimento e causa out-of-memory. A solução foi armazenar os bytes do ciphertext em um offset fixo nos dados da conta, nunca como campo de struct, escrevendo em chunks de 880 bytes ao longo de ~19 transações sequenciais.

Outro desafio foi integrar uma biblioteca FHE nativa em Rust (tfhe-rs) com um worker em Node.js, mantendo a separação de responsabilidades e garantindo que o sidecar sobreviva a reinicializações e gere suas próprias chaves de forma determinística.

----------------------------------------------------------------

Stack Tecnológico Completo:

Blockchain Layer:

- Rust + Anchor: programas on-chain

- Solana Devnet: rede de deploy

- tfhe-rs 0.7: biblioteca FHE nativa com ServerKey para aritmética homomórfica genuína

Off-chain Worker:

- Node.js / TypeScript: coordenador de eventos e escrita on-chain

- fhe-sidecar (Rust + actix-web): servidor HTTP isolado para todas as operações FHE

- REST API com autenticação por assinatura de wallet

Frontend:

- React / TypeScript: interface do usuário

- Phantom Wallet: conexão de carteira

- Vite: bundler

----------------------------------------------------------------

Workflow:

1. Mint: usuário chama swap_sol_for_token(amount) on-chain, SOL vai para o vault. Worker detecta o evento, chama o sidecar para criptografar o valor e escreve o ciphertext na conta do usuário em ~19 chunks.

2. Transferência: usuário registra a intenção no worker via POST /transfer-intent e então chama transfer_request(recipient) on-chain. Worker computa fheSub(senderCt, amountCt) e fheAdd(recipientCt, amountCt) via sidecar e escreve ambos os novos ciphertexts on-chain.

3. Swap reverso: usuário chama swap_token_for_sol_request() on-chain. Worker verifica o saldo, queima o ciphertext, atualiza a reserva do pool homomorficamente e libera SOL do vault para o usuário.

4. Burn: usuário chama burn_request() on-chain. Worker zera a conta confidencial e devolve o SOL equivalente do vault para a carteira do usuário.

----------------------------------------------------------------

GitHub Repository: https://github.com/neylanxyz/ciFHEr
Live demo: https://cifher.vercel.app

----------------------------------------------------------------

----------------------------------------------------------------

EN-US:

ciFHEr - Confidential Token on Solana with Homomorphic Encryption

A fully-collateralized privacy wrapper for SOL where balances and transfer amounts are stored on-chain as FHE ciphertexts. Validators, block explorers, and anyone watching the chain see only encrypted bytes, with no plaintext values exposed.

Details:

ciFHEr solves a fundamental problem with public blockchains: every transaction on Solana is visible to anyone. Your balance, who you paid, how much you swapped — all of it exposed in a block explorer. For everyday users that is uncomfortable. For institutions and funds moving serious capital, it is a dealbreaker.

Our solution stores balances and transfer amounts as FHE ciphertexts directly on the blockchain. One cifherSOL equals one SOL locked in escrow. There are no zero-knowledge proofs, no trusted setup ceremonies, no commitments standing in for the real data. The ciphertexts on-chain are the balances.

The encryption is powered by tfhe-rs (Rust, v0.7). A ServerKey enables genuine ciphertext arithmetic: when you transfer tokens, the worker computes:

- newSenderBalance = fheSub(senderCt, amountCt)

- newRecipientBalance = fheAdd(recipientCt, amountCt)

The balances of sender and recipient are never decrypted during the operation. The subtraction and addition happen entirely in ciphertext space. Only the final result is decrypted to be re-compressed into a compact ciphertext before being written back to chain. In future versions, this decryption step will be eliminated entirely using evaluation keys shared across a decentralized operator network, so no single node ever sees a plaintext value.

ciFHEr ships two Anchor programs on Solana devnet:

- confidential-token: confidential token lifecycle — minting cifherSOL by locking SOL in escrow, transferring between accounts with homomorphic balance updates, and burning to redeem SOL

- confidential-swap: confidential swap pool where users trade SOL for cifherSOL without revealing the swap amount, because the pool reserve is itself an FHE ciphertext updated homomorphically on every trade

Programs Deployed on Solana Devnet:

- confidential-token: 86C1FkYaVUjV2wyWmRMrnGhXGNNpnH9aFLAJQKkAtf6u

- confidential-swap: A2vktybx3Nahc7THvSckeVioTobVkHNEXM5ZteGkoLDK

Technologies: Rust, tfhe-rs 0.7, Anchor, Solana, Node.js, TypeScript, React.

----------------------------------------------------------------

About this project and future plans:

ciFHEr demonstrates that real privacy on public blockchains is achievable today without sacrificing protocol auditability. The current single-operator model is the honest starting point for a system that, in the next iteration, distributes the decryption key across multiple independent nodes via threshold FHE.

As the system matures, SOL locked in the vault earns yield through liquid staking, turning idle collateral into passive revenue for the protocol. A governance token aligns operator incentives and opens community participation in protocol decisions.

----------------------------------------------------------------

Roadmap:

Threshold FHE:

- Replace the single operator with a network of independent nodes

- Decryption key split across multiple operators via threshold FHE

- No single node can read user balances

Vault Liquid Staking:

- Deposit vault SOL into Marinade or Jito, earning ~7-8% APY

- Instant redemptions via DEX liquidity with no unstaking queue

- Passive revenue proportional to total locked in the protocol

Protocol Token:

- Incentive alignment for threshold network operators

- Community participation in governance

- Operators earn a share of protocol fees

----------------------------------------------------------------

Challenges:

The biggest technical challenge was fitting 16 KB ciphertexts into Solana's account model. Transactions support at most 1,232 bytes, accounts can only grow 10 KB per transaction, and the BPF heap is 32 KB — a Vec holding 16 KB doubles on growth and causes an out-of-memory error. The solution was to store ciphertext bytes at a fixed raw offset in account data, never as a struct field, writing in 880-byte chunks across ~19 sequential transactions.

Another challenge was integrating a native Rust FHE library (tfhe-rs) with a Node.js worker while maintaining a clean separation of responsibilities and ensuring the sidecar survives restarts and generates its own keys deterministically.

----------------------------------------------------------------

Full Tech Stack:

Blockchain Layer:

- Rust + Anchor: on-chain programs

- Solana Devnet: deployment network

- tfhe-rs 0.7: native FHE library with ServerKey for genuine homomorphic arithmetic

Off-chain Worker:

- Node.js / TypeScript: event coordinator and on-chain writer

- fhe-sidecar (Rust + actix-web): isolated HTTP server for all FHE operations

- REST API with wallet signature authentication

Frontend:

- React / TypeScript: user interface

- Phantom Wallet: wallet connection

- Vite: bundler

----------------------------------------------------------------

Workflow:

1. Mint: user calls swap_sol_for_token(amount) on-chain, SOL goes to the vault. Worker detects the event, calls the sidecar to encrypt the value, and writes the ciphertext to the user's account across ~19 chunks.

2. Transfer: user registers the intent with the worker via POST /transfer-intent and then calls transfer_request(recipient) on-chain. Worker computes fheSub(senderCt, amountCt) and fheAdd(recipientCt, amountCt) via the sidecar and writes both new ciphertexts on-chain.

3. Reverse swap: user calls swap_token_for_sol_request() on-chain. Worker checks the balance, clears the ciphertext, updates the pool reserve homomorphically, and releases SOL from the vault to the user.

4. Burn: user calls burn_request() on-chain. Worker clears the confidential account and returns the equivalent SOL from the vault to the user's wallet.

----------------------------------------------------------------

GitHub Repository: https://github.com/neylanxyz/ciFHEr
Live demo: https://cifher.vercel.app