Privacy for Solana

Compliant, Auditable Privacy with Real-Time Performance.

What are Private Ephemeral Rollups?

MagicBlock brings privacy to Solana with TEE-protected rollups.  Keep your execution fast, composable, and audit-ready.

The Missing Piece for Solana Privacy

With MagicBlock TEE’s there’s nothing holding you back.

Performance
‍

Composability

‍

Confidentiality
‍

Compliance

Efficiency
‍

Traditional Options

Performance

Much slower (hundreds of seconds).
‍

Composability

Custom stacks and different VMs fragment liquidity and break composability.

Confidentiality

Risk of public state exposure or slow cryptography.

Compliance

Hard to align with KYC/audit needs.

Efficiency

Privacy everywhere = high cost, high latency and high overhead.

Building with MagicBlock

Performance

Sub-50ms private execution for real-time apps.

Composability

Solana-native: no bridges, few lines of code.
‍

Confidentiality

TEE rollups: shielded, verifiable, fast.
‍

Compliance

Audit-friendly: Intel TDX attestation.

Efficiency

Selective privacy: TEEs only where needed, extremely cost efficient.

Privacy with Magicblock is Enterprise-ready: compliant, fast, and simple.

What’s possible with Private Ephemeral Rollups

Private Payments

Create and manage private tokens on the blockchain with enterprise-grade security and seamless user experience.

How Private Ephemeral Rollups Power Privacy on Solana

  1. Authenticate  

    Gate read/write access to private state.

  2. Execute  

    Run Solana programs inside TEEs for shielded computation.

  3. Attest  

    Produce Intel TDX-backed proofs for compliance and audits.

rust
#[ephemeral]

#[program]


pub mod counter {

    use super::*;
‍


    /// Initialize the counter.

    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {

        let counter = &mut ctx.accounts.counter;

        counter.count = 0;
       Ok(())

    }
‍


    /// Increment the counter.

    pub fn increment(ctx: Context<Increment>) -> Result<()> {

        let counter = &mut ctx.accounts.counter;

        counter.count += 1;

        Ok(())

    }
‍


    /// Delegate the account to the delegation program

    pub fn delegate(ctx: Context<DelegateInput>) -> Result<()> {

        ctx.accounts.delegate_pda(

            &ctx.accounts.payer,


            &[TEST_PDA_SEED],


            DelegateConfig::default(),

        )?;

        Ok(())

    }
}