Building Confidential Identity and Reputation Systems with ROFL and Plurality

In Web3, identity is still a challenge. Wallets offer pseudonymity, but there's no built-in way to port reputation, verify credentials, or aggregate a trustworthy profile across apps. Worse, most attempts at solving this introduce privacy risks by requiring centralized data handling or repeated disclosures.

Plurality Network is taking a different approach—by combining identity, reputation, and privacy using confidential compute infrastructure powered by Oasis Protocol’s ROFL (Runtime Offchain Logic).

🧩 What Are Smart Profiles?

Smart Profiles are Plurality’s core identity primitive. They work by:

• Aggregating user data (e.g., from social accounts via OAuth)
• Generating verifiable reputation scores and attestations
• Enabling users to selectively share those scores with apps
• Allowing devs to build onboarding and access logic based on private identity metrics

The key here is privacy. These operations happen offchain in a TEE, not in a backend server or on a public chain. Users retain control over their data, and only the attested output—such as a score or proof—is shared.

🔐 Confidential Compute with ROFL

Plurality integrates tightly with ROFL, a confidential execution layer developed by Oasis. Here’s what that enables:

• Private data ingestion: Users connect social accounts or external sources, but the raw data never leaves the secure enclave.
• Reputation computation or AI training: Custom logic runs offchain in the TEE (WASI-compatible), without gas or exposure.
• Cryptographic attestation: The enclave signs a proof that computation ran correctly and unmodified.
• Onchain verification or publishing: Attested results can be pushed onchain, stored via Oasis Sapphire, or queried by apps.

So essentially, the entire identity and scoring flow runs offchain—but remains verifiable and tamper-proof.

🧰 Tools for Developers

Plurality offers an SDK that abstracts much of the complexity. As a developer, you can:

• Request access to a user’s verified profile or specific attestations
• Tailor your app experience based on user trust signals
• Avoid storing PII or managing sensitive workflows

30+ apps already use it, and you can try out Smart Profiles at app.plurality.network.

Under the hood, the stack looks like this:

• OAuth bridges (e.g., Twitter, GitHub)
• ROFL logic to score, cluster, or analyze identity traits
• Sapphire for secure, encrypted storage
• Attestation layer to link scores to wallet addresses

🧠 Use Cases

Plurality unlocks a broad range of identity-native features for dApps:

• Reputation-based access control in DAOs, DeFi, and social platforms
• Private AI agents that learn from user behavior without leaking data
• Web3-native onboarding without repeated verifications
• Trust graphs that reward credible participants while preserving anonymity

It’s a middle path between anonymous wallets and full KYC—an identity system owned by the user, not a third party.

🌐 Final Thoughts

Identity in Web3 is evolving. With tools like ROFL, we no longer need to sacrifice privacy for personalization or verifiability. Plurality Network is showing how confidential compute and reputation systems can co-exist in a modular, developer-friendly way.

If you’re building an app that needs trust signals, identity proofs, or private user analytics—without handling raw data—Smart Profiles on ROFL is worth a look.

---

Links:

• 🧪 Try it live: app.plurality.network
• 🔧 Developer docs: ROFL documentation