TEN Protocol

TEN Protocol is an encrypted Ethereum Layer-2 (L2) network built for AI-native applications, iGaming, and privacy-preserving smart contracts. By executing code inside Trusted Execution Environments (TEEs), TEN enables encrypted, autonomous, and composable on-chain apps — unlocking private DeFi, verifiable AI agents, and complex on-chain games. TEN makes crypto feel like normal apps—private, simple, and trustworthy—by hiding sensitive logic while keeping Ethereum’s security.

Overview

TEN brings compute-in-confidence to Ethereum. Instead of exposing every variable and instruction to the public mempool, TEN executes sensitive parts of a contract within secure hardware enclaves, then anchors results to Ethereum. The outcome is a new class of on-chain experiences that preserve user privacy, protect proprietary logic, and remain fully programmable and composable.

What Makes TEN Different

• Encrypted execution: Contract state and logic stay encrypted while “in use,” not just at rest or in transit.
• TEE-backed trust: Secure enclaves enforce code integrity and confidentiality, with hardware attestation proving what ran.
• Ethereum security: Results finalize on Ethereum, so settlement and data availability inherit L1 security assumptions.
• Composability without exposure: Private components interact with public contracts, enabling hybrid apps that share only what’s necessary.
• Developer-friendly: Build with familiar Ethereum tooling and patterns while selectively marking functions for encrypted execution.

How TEN Works (High Level)

1. Define private logic: Developers choose which functions, parameters, or model prompts must execute inside TEEs.
2. Run inside enclaves: The TEE decrypts inputs, executes deterministically, and re-encrypts intermediate state.
3. Attest & commit: The enclave produces attestations; TEN posts commitments and results to Ethereum for verification and finality.
4. Compose on-chain: Other contracts can consume the outputs without learning the sensitive inputs or algorithms.

Flagship Use Cases

• Private DeFi: Sealed-bid auctions, hidden-order books, MEV-resistant routing, credit scoring with confidential inputs.
• Verifiable AI agents: LLM/agent prompts, weights, and context remain private; attestations prove the policy and version that ran.
• On-chain iGaming: Fair games with protected RNG seeds and anti-bot logic; reveal outcomes, not exploitable internals.
• Data exchanges: Compute on sensitive data (KYC, medical, enterprise) to produce proofs/scores without exposing raw records.

For Developers

• Ethereum-native: Deploy contracts that interoperate with the wider EVM ecosystem, wallets, and tools.
• Selectively private: Keep most logic public; route only sensitive functions through TEEs for performance and cost efficiency.
• Deterministic workflows: Enclave execution, attestations, and L1 commits produce repeatable, auditable flows.
• Composability: Private outputs are first-class citizens that other smart contracts can reference and automate.

Security & Trust Model

• Hardware isolation: Enclaves isolate execution from the host environment, limiting data exposure and operator risk.
• Attestation: On-chain verifiers check that approved code and enclave configurations produced the outputs.
• Ethereum settlement: Final state roots and commitments anchor to Ethereum for censorship resistance and durability.
• Defense in depth: Key rotation, policy controls, and monitoring support operational resilience.

Why TEN Matters

Public blockchains unlocked transparency but made some categories—trading, gaming, AI inference—hard to build without leaking alpha, models, or user data. TEN closes that gap: teams can launch private-by-default experiences that still feel like native Ethereum dapps, expanding what’s possible on-chain.

Example Application Patterns

• Sealed-state AMMs: Route orders privately, publish settlement proofs publicly.
• Confidential agent rails: Agents act on user intent and private context with verifiable policies.
• Provable games: Keep strategies/RNG secret while proving fairness and outcomes.
• Enterprise workflows: Run sensitive business logic on-chain without exposing customer or pricing data.