Privacy and REX
45 facts about privacy and rex from 7 Rialo sources. Each one is the explanation Reactor shows after a question, followed by the exact line it rests on.
Test yourself on this topic in AtlasRialo Learn
The compliant stablecoins in the demo enforce policy in real time during transaction execution, not after the fact.
“including compliant stablecoins that enforce policy in real time during transaction execution.”How to Bring Private Credit Onchain
REX, Rialo Extended Execution, lets a credit facility evaluate covenants confidentially while anyone can verify an attestation of the result.
“Rialo's REX (Rialo Extended Execution) environment allows smart contracts to run confidential and verifiable computations.”Upgrading the Consumer Lending Stack
REX decrypts encrypted inputs inside the private environment, runs the logic, wipes memory and posts only a proven result onchain.
“sensitive inputs, such as a borrower's financial records and personal information, are encrypted before submission, decrypted within REX, processed according to the program's logic, and cleared from memory after execution completes. The result is then published onchain with a cryptographic proof that the computation was carried out correctly”Rialo Learn: Modeling Compliant Stablecoins on Rialo
On Rialo compliance is a native protocol feature: the chain enforces policy during execution instead of relying on issuers or frontends.
“On Rialo, compliance is a native protocol feature (the chain itself enforces policy at execution time), eliminating the need to rely on external actors.”The demo policy permits a transfer only when neither the sender nor the recipient address is on the denylist.
“The policy permits transfers only if both the sender and recipient addresses are absent from the denylist.”The demo schedules 100 stablecoins every 10 seconds for five runs, 500 in total, with Rialo triggering each execution natively.
“creates a recurring payment that transfers 100 stablecoins to an address ( 5eKo…nvk ) every 10 seconds for five transactions, for a total of 500 stablecoins.”Rialo re-evaluates the policy before every scheduled execution, so once the recipient is denylisted the workflow halts and remaining payments are canceled.
“After these early payments are executed, the recipient address is added to the denylist, making future transactions non-compliant.”Policy is evaluated during execution, and a transaction that fails the check is aborted so no state change occurs.
“If a transaction does not satisfy the required policy, execution is aborted, and no state change occurs.”Recurring and scheduled transactions run inside the protocol on Rialo, with no offchain keepers involved.
“Transactions can be scheduled or executed on a recurring basis on Rialo without relying on offchain keepers.”The policy itself lives in an offchain policy engine, but the Rialo protocol evaluates it during execution and blocks any failing transfer.
“During execution, the protocol evaluates the stablecoin's configured compliance policy, which is hosted by an offchain policy engine.”The guide says REX private execution, native Web2 connectivity and reactive transaction automation combine into a supermodular compliance system.
“this behavior emerges from the composition of the following tightly integrated capabilities: Native private execution (via REX) Native Web2 connectivity Native automation via reactive transactions”Building Native Privacy for Real-World Blockchain Adoption
REX is the name the post gives Rialo's privacy-preserving execution layer, which computes over encrypted user inputs to advance the chain state.
“introducing a privacy-preserving execution layer (let's call it "Rialo Extended Computation," or REX) that uses confidential computation over user inputs to securely and efficiently advance the blockchain state”The post says the problem has less to do with cost and speed and more with public chains being unable to process sensitive data privately.
“The problem has less to do with cost and speed and more with the inability of (public) blockchains to handle sensitive information privately and securely.”The post contrasts $10 trillion in expected cybercrime losses for 2025 with only $200 billion of global cybersecurity spending.
“losses from cybercrime are expected to top $10 trillion in 2025 alone–even as investment in cybersecurity remains negligible ($200 billion in global cybersecurity spending this year)”The post walks through Secure Multiparty Computation, Fully Homomorphic Encryption and Trusted Execution Environments as the three PET options.
“Techniques such as Secure Multiparty Computation (MPC), Fully Homomorphic Encryption (FHE), and Trusted Execution Environments (TEEs) enable processing transactions without revealing inputs or intermediate states.”MPC nodes jointly evaluate a circuit, and large circuits need too many communication rounds, so it suits simple, small computations.
“MPC works best when the computation is reasonably simple and the circuit is small; otherwise, it requires too many rounds of communication.”FHE still has large overhead for general computation, but the post says it can already power smaller tasks like private stablecoins or swaps.
“However, FHE is today ready for smaller computation and can be used for instance to build private stablecoins or private swaps.”In MPC the inputs are secret shared among the nodes, so no node ever sees the raw data, and the nodes jointly evaluate the circuit.
“In an MPC system, transaction inputs are shared as a secret among network nodes (no node has access to the raw data), and computation is expressed as a logical circuit that nodes jointly evaluate.”A TEE cryptographically attests to its result by signing the output and proving the program ran inside the original, unmodified hardware enclave.
“the TEE can cryptographically attest to the result of the computation–signing the transaction output and generating a proof that the requested program was executed within the original, unmodified hardware enclave”The post calls a TEE effectively the same as FHE, but the differences are that multiple nodes must run TEEs and agree, and computation is much faster, not slower.
“which makes a TEE effectively the same as an FHE scheme–the difference is that we require multiple nodes to run TEEs and agree on the results for fault tolerance and but computation is much faster”ZK proofs mostly prove public computation was done correctly and do not address running arbitrary programs over private inputs, so the post calls them orthogonal.
“they are mainly used to prove the correctness of public computation–especially when used in a ZK-VM–and do not address the challenge of executing arbitrary programs over private inputs”The orchestration layer runs computation only after both the application and the data owning user explicitly authorize it, which enables sensitive use cases.
“Rialo's orchestration layer ensures that computation is performed only after explicit authorization from the application and the user (who owns the data)”Only the onchain payouts are public; the participation data, the credentials and the execution traces all stay private inside the REX environment.
“payouts remain public, but the underlying data (e.g., each user's points), authentication credentials, and the execution traces all remain private”The post's policy enforcement example checks a user's nationality confidentially so apps can gate access by country without exposing PII.
“For example, an application can gate access by country of origin and verify a user's nationality before approving their request to interact with the application.”Rialo calls the costs of outsourcing functions like privacy to external layers compound marginalization, the opposite of the supermodularity it aims for.
“At Rialo, we describe the economic and technical effects of excessive modularization as "compound marginalization".”The post argues the opposite: outsourcing privacy adds trust assumptions and costs, so Rialo makes privacy a protocol native feature of the base layer.
“Rialo takes a different approach by providing privacy as a protocol-native feature. Doing this strengthens our goal of maximizing supermodularity”Data fetched by native web calls can be consumed in encrypted form, so a lending app can check a credit score without putting it onchain.
“A lending platform might check a prospective borrower's credit score when issuing a loan without publishing the credit score onchain, for example.”This line is from the post Building Native Privacy for Real-World Blockchain Adoption.
“With privacy-preserving computation, these checks can be run confidentially within a secure execution environment without exposing sensitive PII.”Building Blocks of Threshold Cryptography: Distributed Key Generation
DKG removes the trusted dealer: the group creates the shared secret collectively so no one party ever holds or distributes the full key.
“DKG gives a group a way to generate shared key material without trusting a single dealer to create and distribute it.”With a 3-of-5 threshold, any three of the five share holders can sign together, and no single person ever controls the private key.
“If the threshold is 3-of-5, any three participants can combine their shares to produce a valid signature without any single person controlling the private key.”DKG hides the secret as the constant term of a polynomial, which is the curve's value at x = 0.
“where the hidden secret sits at one special point, namely at x = 0. In polynomial form, that is the constant term”Each participant sends n − 1 shares and receives n − 1 shares, so the whole group exchanges n(n − 1) private messages.
“If there are 𝒏 participants, each participant sends 𝒏 − 1 shares and receives 𝒏 − 1 shares, for 𝒏(𝒏 − 1) messages in total.”Adding all private polynomials gives an aggregate polynomial whose constant term is the sum of the participants' secret values, and that sum is the group secret.
“Because each participant's secret appears as the constant term of its own private polynomial, the constant term of the aggregate polynomial is the sum of those secret values”Lagrange interpolation rebuilds a polynomial from enough of its points, so t key shares recover the curve and its constant term, the secret.
“Participants recover the group secret from their key shares using Lagrange interpolation, which reconstructs a polynomial from sufficiently many of its points.”The coefficients in the example are 3, negative 3 and 1, giving f(0) = 3x₁ − 3x₂ + x₃, so the second coefficient is negative.
“if you use 𝒙₁, 𝒙₂, and 𝒙₃, then 𝒇(0) = 𝒙₁ · λ₁ + 𝒙₂ · λ₂ + 𝒙₃ · λ₃, with λ₁ = 3, λ₂ = −3, and λ₃ = 1”The group public key is Y = gˢ with g a fixed public base element, and threshold signatures verify against this single Y.
“the protocol derives a corresponding group public key, Y = gˢ , where 𝑔 is a fixed public base element”The post says the opposite: the combined signature has the same form as a normal one, so to a verifier it is indistinguishable from a conventional signature.
“From the verifier's perspective, the signed data is indistinguishable from data signed by a conventional private key.”The Rialo Learn simulation runs setup, polynomial generation, share distribution and then final share computation, with no trusted dealer at any point.
“the protocol executes in four steps: (i) choose the number of participants and threshold, (ii) generate private polynomials, (iii) distribute intermediate shares, and (iv) compute final key shares and derive the public key. There is no trusted dealer at any point in the process.”Once the condition holds, payloads are derived, signed by validator key shares into one threshold signature, and then relayed to the destination chains for execution.
“Once the condition is satisfied, the transaction is queued for execution. Payload generation and threshold signing : Transaction payloads for the destination chains are derived from the original transaction. Validators sign each payload with their key shares to produce partial signatures, which are then combined into a threshold signature. Delivery and execution : Each payload is delivered to the destination chain by a relayer or keeper.”With VSS, participants publish commitments to their polynomial coefficients, letting others check that the share they got matches what was committed.
“they also publish commitments to the coefficients of the polynomial they used to create those shares. Other participants can then check whether the share they received is actually consistent with what was publicly committed.”Vanilla DKG assumes honest behavior and cannot detect or mitigate bad shares; that is why the post introduces Verifiable Secret Sharing.
“Vanilla secret sharing based on DKG principles assumes honest behavior and cannot detect or mitigate adversarial actions.”The stablecoin protocol uses Rialo as a coordination hub: a master account on Rialo controls remote accounts, including those that mint and burn.
“Suppose a stablecoin protocol uses Rialo as a hub to coordinate workflows across multiple blockchains. It has a master account on Rialo that controls other accounts deployed on destination chains, including accounts responsible for minting and burning.”This line is from the post Building Blocks of Threshold Cryptography: Distributed Key Generation.
“Validators sign each payload with their key shares to produce partial signatures, which are then combined into a threshold signature.”Rialo Foundations II: Supermodularity and Blockchain Integration
The validator decrypts, calls the account, checks the balance inside shielded compute, transfers if allowed, then erases the credential and posts the result.
“The validator processing this transaction will decrypt it, make a call to the account using the authentication token, evaluate the balance in a shielded computation environment, and complete the transfer if the balance condition is met. Afterwards, the credential is erased from memory, and the outcome is posted onchain for verification”