COTI_Official

TL;DR
→ Garbled Circuits (GC) are a protocol for secure multi-party computation.
→ Several parties jointly compute a function on private inputs and learn only the result, never each other’s data.
→ GC stayed mostly academic for decades because hardware and the right optimizations were not ready.
→ COTI, in partnership with Soda Labs, built the first production-ready, optimized GC implementation on a live blockchain.
→ The gcEVM has been live on COTI mainnet since March 2025.
→ COTI GC is up to 3,000x faster and 250x lighter than alternative privacy solutions, fully EVM-compatible.
The History of Garbled Circuits
To understand why COTI’s implementation matters, start with the lineage. Garbled Circuits are the payoff of a 40-year arc in cryptography that began with a single, elegant question.
1982: Yao’s Millionaires’ Problem. Computer scientist Andrew C. Yao asked whether two millionaires could learn who is richer without revealing how much either one has. His paper, “Protocols for Secure Computations” (FOCS 1982), seeded an entire field: secure multi-party computation (MPC).
1986: The garbled-circuit technique. Yao introduced the construction now known as garbled circuits in “How to Generate and Exchange Secrets” (FOCS 1986). The idea was to encrypt a function, expressed as a Boolean circuit, so it could be evaluated without revealing the inputs. Yao later received the Turing Award in 2000.
Why it stayed on the shelf. For years, GC was theory. Computers were not powerful enough, and most research focused on encrypting data rather than computing on encrypted data. The math was sound. The practicality was not there yet.
2004: Fairplay. The first real implementation (Malkhi, Nisan, Pinkas, and Sella) proved that two-party secure computation could actually run, not just exist on paper.
From there, a stack of academic optimizations gradually turned GC from elegant theory into deployable infrastructure. Garbled Circuits went from a beautiful idea to real infrastructure as decades of improvements stacked up. COTI is where that arc meets a live blockchain.
COTI GC and Soda Labs
COTI built its Garbled Circuits implementation in partnership with Soda Labs, a team specializing in multi-party computation. Together they achieved what had not been done before: the first optimized Garbled Circuits implementation on a blockchain, engineered to run on a small fraction of the compute and memory that earlier GC required.
The production engine is the gcEVM, COTI’s EVM implementation powered by Garbled Circuits. It is the first production-ready GC implementation for on-chain confidentiality, and it is fully EVM-compatible. Developers write confidential contracts in standard Solidity using familiar tooling like Hardhat, adding privacy parameters to unlock MPC.
This is in production, not on a whiteboard. The gcEVM has been live on COTI mainnet since March 26, 2025, with over 125 million on-chain transactions to date.
External validation. Ethereum co-founder Vitalik Buterin has publicly pointed to Garbled Circuits as the path to pure-cryptographic security guarantees for multi-party computation, calling out the two-party case specifically. COTI is the project that shipped it.
“I would love to see at least the two-party case solved with garbled circuits so we can get pure-cryptographic security guarantees.”
Vitalik Buterin, Ethereum co-founder
How COTI GC Works
GC simply explained
Picture two people who each whisper a number into a separate locked box, then walk out of the room knowing who had the larger number. Neither one ever opened the other’s box. That is what Garbled Circuits make possible. The room is the blockchain, and the boxes are pure cryptography.
Think of it as encryption you can compute on. Normal encryption protects data while it is sitting still. Garbling protects data while it is being used: the contract runs the logic on encrypted inputs and reveals only the answer.
And you stay in control of the switch. You choose what stays private and what stays public, inside one ordinary smart contract.
GC technically explained
Function to Boolean circuit. The function being computed is expressed as a circuit of logic gates (AND, OR, NOT, XOR) operating over binary inputs.
Garbling. The “garbler” encrypts the circuit itself, not the data. Gates and input wires are encrypted so the output is only recoverable with the right evaluation keys. Garbling encrypts functions, not data.
Oblivious Transfer (OT). Through OT, the evaluator obtains the evaluation keys for their inputs without the garbler learning which inputs were chosen.
Evaluation. The evaluator runs the garbled circuit and learns only the output, never the other party’s inputs or any intermediate values.
On COTI, this is realized through a concrete data-type lifecycle inside the gcEVM:
Inputtext (it): an encrypted user input plus a signature that binds the sender address, contract, function, and value.
Garbledtext (gt): the live, in-gcEVM encrypted form that computation actually runs on, for example gtUint64.
Ciphertext (ct): the encrypted form used for storage, for example ctUint64. onBoard and offBoard move values in and out of the gcEVM.
Usertext (ut): a value offboarded to a specific user’s key for client-side decryption.
Keys and decryption. The gcEVM uses per-user AES keys, retrieved through a precompile (getUserKey) using an RSA keypair and an ECDSA signature. The network key is an AES key split across nodes with threshold cryptography, so no single node can reconstruct it.
Trust model. Security rests on a threshold of network nodes behaving honestly, combined with battle-tested symmetric-key cryptography. There is no trusted setup. COTI GC does not depend on hardware secure enclaves or TEEs. An enclave can be an optional extra layer, but it is never a requirement, a deliberate contrast with enclave-only privacy systems.
Quantum resistance by design. Because the foundation is symmetric-key cryptography (AES), resistance comes down to key length. The Helium upgrade’s native 256-bit arithmetic already runs at quantum-safe key sizes.
What COTI GC Can Do
The MPC difference. Zero-knowledge approaches typically prove a statement about one party’s hidden data, and often push that data off-chain. Garbling supports computation over private inputs from many parties or owners at once, with private storage alongside Ethereum’s public global state. That is what “multi-party” buys you, and it is the structural advantage over single-source privacy.
What the gcEVM supports. Through MPC Core, developers get encrypted arithmetic (add, subtract, multiply, divide, remainder, with checked variants that carry overflow bits), comparisons (eq, ne, gt, ge, lt, le), bitwise operations, min and max, mux (an encrypted conditional), encrypted randomness, and confidential transfer and transferWithAllowance.
Programmable privacy. You can mix private and public state in a single Solidity contract, choosing inline what stays encrypted. Privacy becomes a property you annotate, not a separate system you bolt on.
Live use cases today:
Private DeFi: confidential trading, private arbitrage (live on Bancor’s Arb Fast Lane), and sealed-bid auctions, with MEV and front-running mitigation because key data stays encrypted.
Healthcare supply chains: VaccineLedger has processed over 10 million private on-chain transactions for cold-chain monitoring in Bangladesh.
Private hardware wallets: United Network’s card-tap confidential transactions.
Private tokens and encrypted messaging: through the COTI MetaMask Snap and community tools like CipherTrade.
One-click private assets: the Privacy Portal converts supported public tokens on the COTI Network into private tokens, and back again, directly from your wallet.
AI agents and identity: confidential agent payments, agent-to-agent messaging, and private identity registries.
Governance: private voting without exposing individual inputs, the exact case Vitalik Buterin described.
Reach beyond COTI’s chain. Privacy-on-Demand extends Garbled Circuits natively to other leading chains, including Ethereum and leading L1s and L2s, so applications elsewhere can tap COTI GC as a service layer rather than migrating to a separate network.
More broadly, the cryptography unlocks the classic MPC use cases the field has chased for decades: privacy-preserving auctions, joint data analysis between organizations, and secure voting.
Start Building with COTI GC.
Pick your language. The Quickstart supports three paths: Solidity, TypeScript, and Python.
Solidity fast path:
Clone coti-contracts-examples, run npm install, then npx hardhat compile.
Run npm run test-private-token to see a confidential token in action. Other examples include test-private-nft, test-private-auction, test-private-identity-registry, and test-on-chain-database.
Get testnet funds. Create an account on first run, then fund it through the faucet at faucet.coti.io (the Discord bot also works: testnet <address>).
The core library. MPC Core is where the privacy lives. Import it with @coti-io/coti-contracts/contracts/utils/mpc/MpcCore.sol to get the private data types (it, gt, ct, ut), onboarding and offboarding, encrypted arithmetic, comparisons, mux, and encrypted randomness.
The tooling that already works: Hardhat, the Remix plugin, the TypeScript SDK (coti-ethers), the Python SDK and Web3.py, the COTI MetaMask Snap, and the Developer Sandbox.
The mental model. Write a normal Solidity contract. Declare the values you want private using COTI’s encrypted types. The gcEVM runs the MPC underneath. It is the standard EVM workflow, with confidentiality added by annotation.
Go deeper. The Build on COTI docs cover Core Concepts (private data types, supported operations, account onboarding), guides for writing a private smart contract and best practices, and the full whitepaper.
Start building with COTI Garbled Circuits → docs.coti.io
Forty years ago, Garbled Circuits were a thought experiment about two millionaires. Today they are live infrastructure processing real value on a public blockchain, and open for anyone to build on. The arc from theory to production is complete. What gets built next is up to you.
Stay COTI.
About COTI:
COTI is the programmable privacy layer for Web3. Built for enterprises, builders, and agents. Powered by high-performance Garbled Circuits and enterprise-grade COTI Nightfall (ZK), COTI enables encrypted computation on any public blockchain. Fast, low-cost, and compliant privacy across DeFi, AI, and beyond.
For COTI updates and to join the conversation, be sure to check out our channels:
Website: https://coti.io/
X: https://twitter.com/COTInetwork
YouTube: https://www.youtube.com/channel/UCl-2YzhaPnouvBtotKuM4DA
Telegram: https://t.me/COTInetwork
Discord: https://discord.gg/coti-foundation
GitHub: https://github.com/coti-io
Vibe Coders Telegram: https://t.me/+uuPNfRkKiQ03ZTcx

TL;DR
→ ERC20 is the most widely used token standard in crypto, but runs on public ledgers where every balance and transfer is exposed. → COTI brings privacy to ERC20 at the protocol level → Private ERC20s bring shielded balances, transfer amounts, and allowances. Only the holder can decrypt their own balance. → Seven tokens are already live and private: COTI, wETH, wBTC, USDT, USDC.e, wADA, and gCOTI. → COTI Garbled Circuits privacy is expanding across Ethereum and leading EVM → The standard that runs Web3 becomes a standard that can run privately.
ERC20: The Standard That Runs Web3
ERC20 is the most widely adopted token standard in crypto history. Stablecoins, governance tokens, smart contract assets, and the vast majority of on-chain value runs on it.
The reason it won is coordination. A single shared standard unlocked composability that compounded across the entire ecosystem. Wallets supported every token by default. Exchanges listed new assets fast. DeFi protocols accept any ERC20 as collateral with zero custom integration work.
However, every token you hold, every amount you move, every balance you carry. All of it sits in the open on a public ledger, readable by anyone. The standard that coordinated an entire industry was never built to keep a single thing private.
COTI Changes this.
ERC20 Is Everywhere
ERC20 did not stay on Ethereum. It spread across the EVM world: Ethereum, where it started, plus Arbitrum, Optimism, Base, Polygon, Avalanche (C-Chain), BNB Chain, and more.
Even where a chain adapts the standard, like BEP-20 on BNB Chain, the base stays ERC20-compatible. That compatibility is the point. One interface, recognized everywhere, is what lets value and applications move across the ecosystem without friction.
The Catch: It Is All Public
Here is the part the standard never solved. Until now, every ERC20 token has lived on a public ledger. Every wallet, every balance, and every transfer is fully exposed and readable by anyone.
Transparency has a cost. Open positions invite front-running and MEV. Large holders get tracked and targeted. Salaries, invoices, and settlement amounts become public the moment they move on-chain. For most real financial activity, broadcasting everything is not a feature. It is the blocker.
COTI Brought Privacy Native to ERC20
COTI added privacy where it belongs: at the protocol level.
With Private ERC20, balances are encrypted, transfer amounts are encrypted, and allowances are encrypted. None of it is broadcast on-chain in the clear.
Each holder has a personal key. Only they can decrypt their own balance. Everyone else, including validators, sees ciphertext. Privacy is the default state, not an add-on.
And because Private ERC20 stays fully ERC20-compatible, it keeps the property that made the standard win in the first place. If you can build with ERC20, you can build with Private ERC20. Privacy inherits the same coordination power that ERC20 already proved.
Privacy Portal: 7-Private Tokens Live Today
Seven tokens are private and usable on COTI right now:
COTI
wETH
wBTC
USDT
USDC.e
wADA
gCOTI
Each can be held, sent, and received privately, directly in the MetaMask wallet people already use, through the Privacy Portal.
→ Try the Privacy Portal: privacy.coti.io.
The Stablecoin Moment
Stablecoins are the breakout crypto technology transforming the World. People all over the world are transacting and using stablecoins for borderless, peer-to-peer payments. Stablecoin volumes and activity is skyrocketing for business and people across the Globe.
They are also where privacy matters most, because the amounts are real: payroll, invoices, B2B settlement, treasury movement. Public balances make those use cases hard. No business wants its payroll or its settlement amounts visible to competitors and counterparties.
Two major stablecoins, USDT and USDC.e, are already private and live on COTI. The killer app for on-chain value now has a privacy-preserving home.
The Capability: Any Public Token, Made Private
The seven tokens are the beginning not the end. COTI’s Garbled Circuits privacy can take a public token on any EVM chain and make it private. This means any DeFi application or dApp with a demand for privacy can enable private tokens and unlock a wide-variety of use cases.
Garbled Circuits is a cryptographic protocol for secure multi-party computation (MPC). It is fast, low-cost, and runs without a trusted setup or specialized hardware. That is what makes privacy at this scale practical, rather than a heavy, slow layer bolted on top.
Privacy On, Everywhere ERC20 Lives
This is the payoff. As COTI’s GC-powered privacy expands across Ethereum and leading L1 and L2 chains through Privacy-on-Demand, the standard that runs Web3 becomes a standard that can run privately.
Privacy on the most widely used tokens, on the leading chains, in the wallets people already use. The protocol standard that united the DeFi revolution, can now unlock a new movement, built on privacy.
COTI: Privacy On
ERC20 proved that one shared standard can transform and bring an entire ecosystem. COTI is giving that standard the one thing it was missing: privacy, built in.
The category is Private DeFi, and the switch is already live.
Get started with Private Tokens: → Try the Privacy Portal: privacy.coti.io.
New to Private ERC20?
→ Read the launch post, Meet Private ERC20.
Build with Privacy
→ Start with the Private ERC20 docs at docs.coti.io.
Stay COTI.
About COTI:
COTI is the programmable privacy layer for Web3. Built for enterprises, builders, and agents. Powered by high-performance Garbled Circuits and enterprise-grade COTI Nightfall (ZK), COTI enables encrypted computation on any public blockchain. Fast, low-cost, and compliant privacy across DeFi, AI, and beyond.
For COTI updates and to join the conversation, be sure to check out our channels:
Website: https://coti.io/
X: https://twitter.com/COTInetwork
YouTube: https://www.youtube.com/channel/UCl-2YzhaPnouvBtotKuM4DA
Telegram: https://t.me/COTInetwork
Discord: https://discord.gg/coti-foundation
GitHub: https://github.com/coti-io
Vibe Coders Telegram: https://t.me/+uuPNfRkKiQ03ZTcx

TL;DR
→ Der Datenschutz geht inzwischen netzübergreifend live. Was sich tatsächlich unterscheidet, ist die Kryptografie im Inneren – und die Trade-offs sind nicht gleich.
→ Die meisten hochvertraulichen Netzwerke erlauben einem Betreiber, einer Institution oder einem zugelassenen Knoten, deine Daten im Klartext zu lesen. Nur wenige verschlüsseln den gesamten Weg.
→ COTI verwendet Garbled Circuits: Verträge werden auf verschlüsselten Daten ausgeführt, die niemand einsehen kann – auf jedem Gerät, in Standard-Solidity.
→ Die COTI-GC-Privacy ist live – nicht nur theoretisch.
→ Der COTI-Token ermöglicht private Transaktionen über mehrere Chains, Protokolle hinweg und für jede programmierbare Privacy-Lösung.