bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 12쪽 중 1쪽
Your Toolkit to Build Privacy Apps
Welcome to iExec
Your complete toolkit for building privacy-first crypto applications that protect and use sensitive data.
Why iExec?
You shouldn't have to choose between innovation and privacy.
Every developer deserves the power
to build groundbreaking applications while
keeping user data completely secure
. Your users deserve
absolute confidence
that their privacy is protected.
iExec solves this with
Privacy tools
- a toolkit that simplifies data protection, management, and secure computation, even in untrusted environments.
iExec believes privacy should be
plug-and-play simple
, not an afterthought.
How iExec works
iExec provides Privacy tools that make confidential computing simple and actionable:
Privacy:
Integrate confidentiality features without managing complex infrastructure
Governance and Ownership:
Control your assets through orders, choose who can access your data, with which privacy applications, and at what price
Multi-Chain Interoperability:
Build privacy-first applications on supported networks
Available Tools:
Composable toolkit, SDK, and ready-to-use components for straightforward development
Tools & support to build with confidence
Building with iExec means you don't just get the tech—you get a partner.
The iExec toolkit
DataProtector:
Secure and control access to sensitive information
iApp Generator:
Bootstrap your Privacy Apps on TEEs. Confidential Computing made easy
Web3Messaging:
Integrate Web3Mail and/or Web3Telegram to communicate with Ethereum accounts without having access to their personal data.
Support & guidance
Grants & Incentives:
Financial support to help builders bring their ideas to life
Hands-on Guidance:
Our team works alongside you to overcome challenges and scale your project
Shared Vision:
Join a community that's shaping the future of privacy-first applications
Real-world Use Cases
Finance
Analyze sensitive financial data
Process credit scores without exposing personal information
AI/ML
Train models on private datasets
Perform confidential predictions
Research
Share and analyze research data securely
Collaborate while protecting intellectual property
Business Analytics
Process competitive market data
Analyze business metrics confidentially
Gaming
Protect player data and game assets
Process in-game transactions securely
Healthcare
Process patient records privately
Run medical analyses while preserving patient confidentiality
The next chapters guide you through our
Hello World journey
. This 30-minute start teaches you everything about iExec. You'll learn
protecting sensitive data
and
building and deploying confidential apps
.
Start Building
Ready to build privacy-first applications? Choose your path:
Quick Start:
Follow our
Hello World guide
to build your first confidential app in minutes
Explore Use Cases:
Browse
real-world examples
to see what you can build with iExec
Join the Community:
Connect with other builders and get support on our
Discord
Join thousands of developers
who are already transforming the future of privacy.
You have the power
to build the next generation of trust-first applications. Let's build something amazing together.
🚀
🏆 Join the iExec Community
Be part of a growing movement of developers, data owners, and privacy advocates who are
reshaping how the world handles sensitive data
.
When you build with iExec, you're not just solving a technical challenge
you're championing user rights and digital sovereignty
. Every application you create makes the web more private, more secure, and more trustworthy for everyone.
## /guides/build-iapp/build-&-test
Build and Test an iApp
iApp (iExec Applications) are decentralized applications that run on the iExec network. They use confidential computing to ensure data privacy and security while providing scalable off-chain computation.
About iApp Generator
Bootstrap TEE-compatible applications in minutes without any hardcoding skills, iApp Generator handles all the low-level complexity for you.
Select your project mode & language
- Get started with either a basic or advanced setup, depending on your experience with the iExec framework. You can use Python or JavaScript—whichever you prefer!
Develop your iApp effortlessly
- Write your application logic using familiar programming languages while the generator handles all TEE-specific configurations.
Access to TEEs easily
- No need to dive into low-level requirements, create iApp that connect to TEEs in minutes.
Check and deploy iApp quickly
- iApp Generator checks that your iApp complies with the iExec Framework and streamlines its deployment.
Prerequisites
First, install iApp Generator in your project (for more details see
iApp Generator Getting Started
):
npm
yarn
pnpm
bun
bash
npm
install
-g
@iexec/iapp
bash
yarn
global
add
@iexec/iapp
bash
pnpm
add
-g
@iexec/iapp
bash
bun
add
-g
@iexec/iapp
Quick Start
Once installed, you can create and deploy your first iApp. The CLI will guide you through an interactive setup process to configure your project name, programming language, and template:
Terminal
$
iapp init
_ _
(_) / \ _ __ _ __
| | / _ \ | '_ \| '_ \
| |/ ___ \| |_) | |_) |
|_/_/ \_\ .__/| .__/
|_| |_|
After the interactive setup, continue with development and deployment:
Development and Testing
Navigate to your project and run tests locally to simulate the TEE environment. The CLI will build a Docker image, run your app, and show you the results:
Terminal
$
iapp test
Next Steps
When everything is ready
deploy and run your iApp
## /references/dataProtector
DataProtector
2.0.0
DataProtector
simplifies secure data management
, offering users essential tools for protecting, managing, and sharing their data effectively.
DataProtector Core
As the foundational component of DataProtector, DataProtector Core provides essential functionalities for data protection. Users can
encrypt their data
and
record ownership on a smart contract
, ensuring confidentiality and traceability. Granting access to authorized applications is streamlined, facilitating secure data management.
With
DataProtector Core
, you can
grant access
to your protected data
to a specific user
.
You define the number of times the user can access the data.
You should choose an iApp (iExec TEE Dapp) that will be able to process your protected data.
You'll have to sign a transaction at the moment you grant access to the user and the iApp (iExec TEE Dapp).
## /protocol/proof-of-contribution
Proof-of-Contribution (PoCo)
What is PoCo?
PoCo (Proof-of-Contribution) is the trust and governance layer of the iExec protocol. It ensures that off-chain computations running inside Trusted Execution Environments (TEEs) are executed correctly, confidentially, and under clear economic rules.
PoCo provides three core guarantees:
Confidentiality
: data and secrets are only processed inside
TDX
Trust Domains.
Governance and access control
: users decide who can access their data.
Trusted payments and penalties
: contributors get paid automatically, and misbehavior is economically discouraged.
Why PoCo matters?
iExec is built around confidential computing, where computations run inside Trusted Execution Environments. Users don’t need to trust the machine running the task, TEE’s cryptographic attestation prove that execution happens in a private way.
PoCo uses this model to guarantee:
execution happens
inside a genuine Trust Domain
secrets are handled
securely and privately
results come from
verified Trust Domains
payments and penalties are applied
automatically
on-chain.
In short: PoCo allows building production-grade confidential compute workflows, backed by hardware security, without needing to design trust, access, or monetization layers.
How the TEE-centric workflow works?
This reflects the default workflow used today on iExec networks.
The user triggers match orders on-chain operation
A requester matches the app, dataset, and workerpool orders. This creates a
Deal
on-chain and locks the requester’s funds.
PoCo now governs:
who has access
what is paid
under which conditions the task is considered valid
The scheduler assigns the task to a TEE-enabled worker
The workerpool selects an available worker with the required TEE capabilities. No replication is needed, trust comes from hardware attestation, not from multiple workers.
The worker executes the app inside a TDX Trust Domain
The worker runs a confidential application inside its Trust Domain:
the code is measured
the environment is verified
the Trust Domain proves its authenticity through remote attestation
PoCo verifies this attestation through the SMS
This guarantees:
no one can inspect the data
the worker cannot tamper with the execution
results come from a genuine, verified Trust Domain
Secrets are transferred securely (SMS → Trust Domain)
If the task uses secrets (dataset decryption key, ...):
the Secret Management Service (SMS) verifies the worker’s Trust Domain
secrets are provisioned for the specific Trust Domain only
secrets are only accessible and processed inside the TDX Trust Domain.
This is fundamental for confidential and monetizable datasets.
The Trust Domain computes and produces the result
At the end of execution, the Trust Domain:
makes the result available for the requester (on IPFS for example)
signs a challenge to prove that the execution happened inside a Trust Domain
sends the proof to the PoCo via the worker
PoCo validates and finalizes the task on-chain
PoCo checks:
worker permission to push a result for the task (through an off-chain scheduler authorization)
Trust Domain authenticity by validating the Trust Domain challenge signature
If everything is valid the ask is finalized and funds are released according to the on-chain rules:
the requester's locked money is finally seized
the worker gets paid
app & dataset owners get their revenue shares
any misbehavior results in stake-based penalties for the scheduler
Brokering
On iExec,
brokering
is the mechanism that matches all parties involved in a computation:
the
application
(the logic to run)
the
dataset
(optional, confidential input data)
the
workerpool
(TEE-enabled workers)
the
requester
(the user paying for the execution)
Each party publishes an
order
describing what they offer or request. When compatible orders are combined, a
deal
is created and PoCo enforces all economic, confidentiality, and governance rules.
Why off-chain brokering?
iExec uses an
off-chain order book and off-chain matching
system because it provides major advantages:
orders can be created, shared, and canceled
without gas costs
signatures make orders
trustless and verifiable
brokering is fast and flexible
the blockchain is used only to
validate signatures
and
create the final deal
Although off-chain, the system is secure because each order is:
encoded as a structured object
hashed using
EIP-712
signed
by the resource owner
This makes an order
as authoritative as if it were published on-chain
, without paying gas. The
PoCo
smart contract validates every signature and ensures correct matching.
What brokering enables?
Access control / permissioning
Different actors define who can use their resources (specific apps, requesters, or workerpools).
Dynamic pricing & monetization
Apps, datasets, and workerpools set prices; requesters set maximum prices.
Asynchronous, trust-minimized execution
After a successful
matchorders
, the PoCo ensures that all parties can operate asynchronously and without direct trust:
the deal is created on-chain and acts as the single source of truth
the requester does not need to stay online during execution
TEE-enabled workers independently fetch tasks when ready
results, proofs, and outputs are submitted later when execution completes
PoCo guarantees that even though all actors act at different times, the workflow remains secure, deterministic, and economically enforced.
Order structures
Each actor expresses intent through a signed
order
. There are four order types, all using
EIP-712 signatures
:
AppOrder
— how the application can be used
DatasetOrder
— how the dataset can be accessed
WorkerpoolOrder
— what TEE workers are available
RequestOrder
— what the requester wants to run
Every order includes:
the resource address (app/dataset/workerpool/requester)
price
volume (number of times the order can be matched)
optional matching restrictions
a
tag
describing features (e.g., TEE requirement)
a
salt
for uniqueness
a cryptographic
signature
AppOrder
struct AppOrder
{
address app;
uint256 appprice;
uint256 volume;
uint256 tag;
address datasetrestrict;
address workerpoolrestrict;
address requesterrestrict;
bytes32 salt;
bytes sign;
}
DatasetOrder
text
struct DatasetOrder
{
address dataset;
uint256 datasetprice;
uint256 volume;
uint256 tag;
address apprestrict;
address workerpoolrestrict;
address requesterrestrict;
bytes32 salt;
bytes sign;
}
WorkerpoolOrder
text
struct WorkerpoolOrder
{
address workerpool;
uint256 workerpoolprice;
uint256 volume;
uint256 tag;
uint256 category;
uint256 trust;
address apprestrict;
address datasetrestrict;
address requesterrestrict;
bytes32 salt;
bytes sign;
}
RequesterOrder
text
struct RequestOrder
{
address app;
uint256 appmaxprice;
address dataset;
uint256 datasetmaxprice;
address workerpool;
uint256 workerpoolmaxprice;
address requester;
uint256 volume;
uint256 tag;
uint256 category;
uint256 trust;
address beneficiary;
address callback;
string params;
bytes32 salt;
bytes sign;
}
Additional protocol concepts
Tag
The tag specifies the need or the availability of features that go beyond the specifications of the category. The tag is a requirement when it is part of an app order, a dataset order or a requester order. On the other hand, the tag in the workerpool order expresses the availability of the corresponding features.
Tags are 32 bytes (256 bits) long array where each bit corresponds to a feature.
Pre-defined tags:
Value
Description
0x0000000000000000000000000000000000000000000000000000000000000001
(
0b0001
)
TEE
0x0000000000000000000000000000000000000000000000000000000000000009
(
0b1001
)
TEE TDX
For orders matching, the worker pool order must enable all bits that enable in any of the app order, dataset order and requester order. Meaning that if the app order tag is
0x12 = 0x10 | 0x02
, the dataset order is
0x81 = 0x80 | 0x01
and the requester order is
0x03 = 0x02 | 0x01
, then the worker pool order must, at least, have a tag
0x93 = 0x80 | 0x10 | 0x02 | 0x01
.
Reward kitty
When a task fails, the requester gets a refund and the scheduler loses its stake. In order to remove an attack vector, the requester does not get any of the seized stake. If this was a feature, anyone could build a flawed application that would not reach consensus to drain money from the scheduler. This would force the scheduler to whitelist all applications thus reducing the usability of the platform. Seized stake from the scheduler goes into a specific account called the
reward kitty
. No one controls this account, nor can withdraw from it. However, the tokens are not burned. Whenever a task finalizes, the scheduler that organized the execution of this task receives a reward by the requester and also gets a small part of the reward kitty.
As described in the protocol parameters section, this reward is
reward = kitty.percentage(KITTY_RATIO).max(KITTY_MIN).min(kitty)
.
## /get-started/toolkit
iExec Toolkit
Build faster and smarter with our privacy toolkit designed to streamline your iExec development experience.
iApp Generator
The
iApp Generator
is your quick-start solution for creating iExec confidential decentralized applications. Generate production-ready iApp with just a few commands, let free your imagination.
Key Features
Development templates
that simplify iApp development
Streamlined wallet management
for easy app deployment
Governance management
to control who accesses your app, when, and at what price
Get Started
Jump right into building with our comprehensive guide:
Building Your iApp →
DataProtector-SDK
The
DataProtector-SDK
provides a complete toolkit for managing confidential data on iExec. Protect, share, and monetize your data by exposing the protected asset type on the iExec protocol without revealing the actual value, allowing users to pay for access.
Key Features
Easy data protection
through SDK methods
Asset visualization
to easily view and explore protected asset types on the iExec protocol
Content consumption
capabilities for accessing protected data through confidential iExec applications (iApp)
Governance management
to control who accesses your data, when, and at what price
Get Started
Learn how to protect and manage your data:
DataProtector Getting Started →
## /get-started/helloWorld
👋 Welcome to iExec
Reading time 🕒 2 min
🌐 Select Your Network :
Arbitrum One
Start Your Web3 Privacy Journey
And learn how to build Privacy-preserving decentralized applications (DApp) with iExec in this interactive guide.
☕ 30 minutes journey
Perfect for hackathons 😊
What you'll Learn and Build
1 - iExec Overview
8 min read
Discover how iExec technologies work and the problems they solve
Read
2. Protect Your Data
6 min read
Learn to secure your sensitive data using our developer tools
Read
3. Build your iApp
10 min read
Build and run your first iExec App to work with protected data in a safe environment
Read
4. Manage Data Access
6 min read
Learn advanced data access management, permissions and monetization
Read
Bonus Chapter
Finish the journey with a surprise bonus chapter!
Special content
Getting Started
Before you begin, make sure you have:
🦊 Ethereum Wallet
Required to interact with iExec protocol, manage your data access permissions, and handle transactions on the iExec platform
Metamask Download →
📦 Node.js v20+ (for javascript iApps)
Required runtime environment for running JavaScript code and managing project dependencies
Download →
🐍 Python 3.8+ (for Python iApps)
Required runtime environment for Python-based iExec applications
Download →
🐳 Docker installed
Docker is essential for creating isolated containers that package your iExec applications with all dependencies. This ensures consistent and secure execution across different environments, especially in TEEs (Trusted Execution Environments)
Download →
🐳 DockerHub Account
Needed to publish and manage your iExec applications in containers for secure deployment
Sign Up →
Need help setting up or got some questions?
Join our
Discord Community
for support!
## /get-started/helloWorld/1-overview
iExec Overview
Reading time 🕒 8 min
Start with the basics
and explore how iExec can help you build Privacy-preserving apps and securely manage sensitive data.
Building Privacy-preserving iApp with iExec
Imagine you're building a decentralized app (dApp) that needs to
handle sensitive user data
, for example:
🤖 An AI model training on sensitive data
💰 A financial app handling financial data
🔬 A research platform working with private datasets
🏥 A healthcare app processing confidential patient records
You'll need a way to:
🔒 Keep the data confidential
🎮 Control who can access it
⚡ Process it securely
💎 Potentially monetize it
This is where
iExec
comes in! iExec provides tools to easily add
privacy
and
monetization
features into your iApp.
How do we Solve it?
Unlike traditional tools, iExec protects your data throughout its entire lifecycle - during storage, transfer, and even while
being processed by applications.
This is made possible thanks to
Trusted Execution Environment (TEE)
and
Confidential Computing
technologies.
The technology allows users to control the
ownersh프로젝트로 돌아가기