iExec RLC 백서

iExec RLC

원문

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
프로젝트로 돌아가기