What is OXN
OXN is a Layer 1 blockchain that runs a fully compatible Ethereum Virtual Machine inside hardware-protected Trusted Execution Environments (TEEs). Every smart contract executes inside an Intel SGX enclave on every validator, and every piece of contract state, transaction calldata, return data, and event log is encrypted with keys that only the enclave can access.
The result: you get the tools, contracts, and developer experience of Ethereum — plus provable confidentiality that no other public EVM chain offers.
How OXN is different
From public EVM chains (Ethereum, Base, Arbitrum, …)
Every public EVM chain broadcasts your transaction inputs to the world. If you send transfer(alice, 1000) on Ethereum, both alice and 1000 are permanently printed into the public block for anyone to read. This rules out entire application categories:
- Sealed-bid auctions — you cannot hide a bid until reveal if it enters the mempool in the clear
- Private orderbooks — every limit order is visible to searchers running MEV strategies
- Enterprise workflows — supply chain, invoicing, B2B settlement leak business-sensitive numbers
- Voting and governance — vote coercion works when ballots are public
- On-chain secrets and credentials — session keys, secrets, and PII cannot live on a public chain
OXN keeps the same EVM contracts, the same Solidity, the same tools. It changes what's public: contract state, calldata, return values, and event logs are encrypted. What's paid in gas, which contracts got called, and which addresses transacted with each other remain visible so the chain stays auditable.
From rollups (optimistic and ZK)
Rollups are execution shortcuts: they batch Ethereum-compatible transactions off-chain and post a summary back to Ethereum for security. Rollups get you scaling — cheaper gas, faster confirmation — but almost all of them are as public as Ethereum itself. Even ZK rollups only use zero-knowledge proofs to compress state transitions; the inputs to those transitions still land in the public data blob.
OXN is not a rollup. It is a sovereign Layer 1 with its own validators and consensus. It does not post to Ethereum, does not depend on any other chain for finality, and does not share a sequencer.
From private or permissioned chains
Private chains (Quorum, Besu with permissions, Hyperledger Fabric) hide data by restricting who can join the network. That works when you trust the operator, and only between counterparties who all trust the same operator. It does not scale beyond a consortium.
OXN is permissionless. Anyone can join, deploy, and read. Confidentiality is enforced by hardware attestation, not by network access control. There is no operator "not looking" — the enclave prevents them from looking in the first place.
From ZK-based confidential chains
ZK-based chains use cryptographic proofs to hide data. This is a fundamentally different tradeoff:
| Property | TEE-based (OXN) | ZK-based |
|---|---|---|
| Developer experience | Standard Solidity, unchanged | Custom circuit language, new tooling |
| Contract execution cost | ~normal EVM gas | High (proof generation and verification) |
| Trust root | SGX hardware + remote attestation | Pure cryptography |
| Composability with EVM | Native | Bridge required |
| Time to write a confidential contract | Same as a public contract | Days to weeks |
Neither approach is universally better. TEE is more pragmatic when you want existing Solidity to work with minimal changes and normal gas costs. ZK is more conservative when the threat model excludes hardware trust and you can afford the proving overhead.
What OXN is best at
OXN fits when your application:
- Runs on existing EVM code paths (ERC-20 / 721 / 1155, DEX logic, lending, gaming) but needs to hide amounts, balances, or participants
- Needs strong composability with other contracts on the same chain
- Cannot spend the engineering effort or on-chain gas of ZK proofs
- Wants encrypted state that behaves like ordinary storage from the contract author's perspective
OXN is not the right choice when:
- You need to publish a proof of your state transition to a bigger chain (that is what a rollup is for)
- Your threat model excludes hardware root of trust (some regulated environments, extreme adversarial scenarios)
- The application is fundamentally public (open liquidity pools, oracle price feeds, public NFT metadata)
What executes where
OXN has two layers, and both are part of the same L1:
- Consensus layer — produces blocks, agrees on ordering, holds native
oxn1…account balances - Execution layer (EVM) — runs Solidity contracts inside SGX enclaves, holds EVM
0x…account balances
Users normally interact only with the execution layer — that is where MetaMask, Hardhat, ethers.js, and every other Ethereum-shaped tool talks to. The consensus layer is what backs the whole thing with finality, and only becomes visible when moving funds between address formats or (later) when running a validator.
See Architecture Overview for a diagram.