Build
Magic Incubator
Explore Ideas
Docs
Guides
Solutions
Gaming
Trading
Privacy
DePIN
Community
Join the Quest
Discord
X
Youtube
About
Team
Careers
Ecosystem
Blog
Solutions
Gaming
Trading
Privacy for Solana
DePIN
Resources
Docs
Guides
Blog
Community
About
Team
Careers
Ecosystem
Docs
Accelerate
Privacy for Solana
Compliant, Auditable Privacy with Real-Time Performance.
View the Docs
Start Building
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.
Learn More
Start Building
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.
View Demo
How Private Ephemeral Rollups Power Privacy on Solana
Authenticate
Gate read/write access to private state.
Execute
Run Solana programs inside TEEs for shielded computation.
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
<
Incremen
t>) ->
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
(())
} }