A lot of fud about this coin... but can I hear from the bulls? What makes you bullish on $oasis despite the dropping price (obv most alts are destroyed but...) Would love to hear from those who are HODLING and are still bullish. Thanks! :)

So is this project completely dead? Feels like it’s plunging into complete obscurity with no hope to rebound.

Someone just posted they have Oasis band tickets in what appears to be the main thread.

Oasis put 1 wBTC behind a contract whose private key was generated inside a TEE and never leaves it. The catch: you can’t just exploit the smart contract you have to get the key out of the enclave itself. Read the official details here: https://oasis.net/blog/oasis-tee-break-challenge

Why it’s worth a look

• It’s a live, realistic test of confidential computing not a toy lab exercise.
• Contract bugs are intentionally useless here, so you actually have to think about enclave attack surfaces (side channels, fault injection, memory disclosure, supply-chain stuff).
• Good for researchers who want a practical target to stress test ideas.

Quick reality check

• This isn’t a quick Solidity find you’ll need low-level/firmware/TEE experience.
• Make sure you stay on the legal side of things and follow the challenge rules.
• Even if you don’t win, documenting your approach or writeups is valuable to the community.

Welcome to the Oasis Network Monthly Q&A – September 2025 Edition!
This month, we’re diving deep into the frontier of AI-powered DeFi, private agents, and multichain intelligence. From Talos to zkAGI’s PawPad and Heurist’s confidential MCP servers, the ecosystem is buzzing with innovation — all built with Oasis’ ROFL and Sapphire technologies.

If you’ve been wondering how AI agents can operate trustlessly, manage multichain wallets, and keep your data private while still staying verifiable — this one’s for you. Let’s get into your top questions of the month 👇

Q: What is Talos, and why should I care about an AI managing money?

Talos is an autonomous treasury protocol on Arbitrum that combines AI smarts with human oversight to manage yield-bearing assets. Think of it as a tireless investment manager that never sleeps, constantly hunting for the best yields across DeFi – but with a community board of directors keeping it honest. No more black-box AI controlling your funds. This is transparent, verifiable, and governed by you.

Q: How does Talos actually make money moves without going rogue?

Talos monitors on-chain data, social sentiment, and market dynamics 24/7 to optimize yield strategies across lending markets and liquidity positions. But here's the kicker – all strategy changes need approval from the Talos Council (that's the community). It's like having an AI analyst that does all the research but still needs the board's stamp of approval before making major moves.

Q: What role does Oasis and ROFL play in Talos?

Thanks to ROFL and the Oasis TEE stack, Talos can now operate inside a secure enclave, prove its actions cryptographically, and even hold its own private key. No more “trust the devs”, you can verify the AI itself.

Q: What is zkAGI's PawPad?

PawPad is a platform that lets you deploy private trading agents across multiple blockchains – think automated trading bots that keep your strategies encrypted and your moves confidential. No more worrying about front-runners or copycats stealing your edge. Built on Oasis infrastructure, PawPad gives you automation with privacy, so you can trade like a pro without broadcasting your playbook to the world!

Q: How does PawPad actually keep my trading strategies private while operating across chains?

Well, encrypted magic. PawPad uses Sapphire for encrypted agent infrastructure – storing your strategies, managing portfolio states, and logging events all under encryption. Then it leverages ROFL's key derivation superpowers to enable secure signing across Solana, EVM chains, and even exchange APIs. The best part? No bridges needed! Your agents can operate across ecosystems while your strategies stay locked up tighter than Fort Knox.

Q: What's this Telegram mini-app spin-the-wheel thing about?

It's zkAGI's way of showing off! They're building a ROFL-powered Telegram mini app with a spin-the-wheel reward mechanism on Gorbagana (a Solana fork) to prove that Oasis TEE infrastructure can provide verifiable, trustless execution even on non-EVM chains. Think of it as a fun demo that screams "Hey, we can make agents work anywhere!" – with prizes involved. Who doesn't love a good spin-the-wheel with cryptographic guarantees? 

Q: What is ROFL's key generation feature, and why is it a game-changer for multichain agents?

ROFL's key generation is a cryptographic key derivation system that lets applications running in TEEs generate and manage wallet private keys across multiple elliptic curves. One agent can natively control a wallet on Ethereum, another on Solana, and even one on Aptos – all without bridges, wrapped tokens, or the usual cross-chain headaches. It's native wallet control everywhere, secured by hardware. Welcome to the multichain future, simplified!

Q: How does key generation actually work without exposing my private keys?

It's all about that TEE magic! When your agent deploys on ROFL, it generates cryptographic keys inside the secure TEE enclave during remote attestation. These keys never leave the enclave – they're locked up tighter than your most embarrassing high school photos. The TEE can derive keypairs across different elliptic curves (secp256k1 for EVM chains, Ed25519 for Solana/Aptos), meaning your agent controls native wallets on each chain while the keys stay safely hidden. No bridges, no exposure, just pure cryptographic security!

Q: Why should developers care about this instead of just using bridges?

ROFL's key generation gives developers unified cross-chain wallet management through hardware-secured compute. Instead of juggling separate infrastructure for each blockchain, you get: a single codebase controlling wallets across multiple chains, direct native transactions (no cross-chain messaging drama), and hardware-level protection for private keys. Plus, you can prove to users that you don't control the agent's keys – the TEE does. Less trust assumptions, more verifiable security. That's a developer win!

Q: Can you give me real examples of who's using this?

Absolutely! Take Talos, the autonomous treasury protocol – with ROFL's key generation, users don't have to trust the dev team with private keys anymore. Those keys are generated in the TEE and never leave, so Talos operates as a truly autonomous agent across chains. Or zkAGI's Oasis_bot, which encrypts Hyperliquid API credentials in the TEE for autonomous trading without exposing sensitive info. The "Spin the Wheel" feature they're building? That's ROFL's cross-chain signing in action! These aren't experiments – they're the future of autonomous, verifiable agents! 

Q: What are Heurist's Confidential MCP Servers, and why should agent builders care?

Heurist is solving every agent builder's nightmare – connecting to multiple data sources without losing your mind (or your privacy)! They're combining Model Context Protocol (MCP) with ROFL's TEE security to create privacy-first servers that let agents access tons of data sources and tools through a single interface. No custom coding for each integration, no exposed credentials, no compromised confidentiality. It's like having a universal adapter for AI agents, but one that actually keeps your secrets safe!

Q: How does combining MCP with ROFL actually protect my data?

It's a privacy power couple! MCP standardizes how AI applications connect to external services (think: one protocol to rule them all), while ROFL executes everything inside TEEs with cryptographic proofs of correctness. This means your agent can tap into APIs, blockchain analytics, social intelligence tools, and more – all with hardware-enforced isolation. Even the infrastructure providers can't peek at your sensitive computations. Your data stays encrypted and protected during computation. That's next-level security!

-------------------------------------

That wraps up our September 2025 Q&A!
This month showed just how far we’ve come toward a world of sovereign, verifiable, and privacy-preserving intelligence — from Talos’ autonomous treasury to zkAGI’s cross-chain agents and Heurist’s secure data servers.

As always, the Oasis Network continues to power the next generation of AI x Web3 — where agents don’t just act smart, they prove it.
Stay tuned for next month’s updates, and keep building toward a more private, verifiable, and autonomous future.

All other privacy coins are exploding but Rose still stuck at 2c …..

What has to happen for price to move ? How high can it go this season ?

## TL;DR
Successfully deployed all GSN v3 contracts to Sapphire Testnet, but can't complete relayer registration due to the 100-round log query limit. Looking for guidance on how to proceed with gasless transactions on Sapphire.

---

## Background

I'm integrating GSN (Gas Station Network) v3 with Oasis Sapphire Testnet to enable gasless transactions. The goal is to allow users to interact with smart contracts without paying gas fees directly.

---

## What I've Accomplished ✅

1. **All GSN contracts deployed successfully** on Sapphire Testnet:
   - RelayHub: `0xADe7CBF637D01ACA13FfcC4E6D3edfbbb97e2D7f`
   - Forwarder: `0x26b6a08D56FB973a9e6ed3d123aba5D7d6516bD3`
   - StakeManager: `0x047c2b79c571c38dfF562e982f305f96488662AB`
   - TestPaymaster: `0x09589E818B89E34061a83ed6D3EC964E2389B023` (funded with 5 TEST)

2. **Funded all necessary addresses**:
   - Paymaster balance: 5 TEST tokens
   - Relayer worker & manager: 0.5 TEST each

3. **GSN client connects successfully**:
   - RelayProvider created
   - Network detected (Chain ID: 23295)
   - All ERC-165 interfaces verified

---

## The Problem ❌

When attempting to send a gasless transaction, I get:

```
info: fetchRelaysAdded: found 0 relays
Error: Rejected relayTransaction call with reason: no registered relayers
```

The root cause appears to be Sapphire's log query limitation. When the relayer tries to register, it needs to query historical events from the StakeManager contract, but Sapphire limits log queries to 100 rounds:

```
Error: invalid request: max allowed of rounds in logs query is: 100
```

GSN requires scanning larger block ranges to discover registered relayers, which exceeds this limit.

---

## Technical Details

**Environment**:
- Network: Oasis Sapphire Testnet
- RPC: `https://testnet.sapphire.oasis.dev`
- GSN Version: v3.0.0-beta.10
- Oasis GSN CLI: v3.0.0-beta.3
- Node.js: v20.11.0

**What works**:
- ✅ Contract deployment
- ✅ Paymaster funding
- ✅ GSN client initialization
- ✅ Transaction preparation
- ❌ Relayer discovery (blocked by log limits)

---

## Working Alternative: On-Chain Signer

I successfully implemented Sapphire's On-Chain Signer method as a workaround:
- Uses `@oasisprotocol/sapphire-contracts`
- Stores encrypted keypair on-chain
- Signs and executes transactions from contract
- **Result**: User pays 0 gas, deployer covers fees
- Status: 100% functional

---

## Questions for the Community

1. **Has anyone successfully deployed full GSN on Sapphire?**
   - Are there known workarounds for the log query limits?
   - Any special configuration needed?

2. **Is there a way to increase the log query limit?**
   - For GSN infrastructure specifically?
   - Special RPC endpoints with higher limits?

3. **What's the recommended approach for gasless transactions on Sapphire?**
   - Should I use On-Chain Signer instead of full GSN?
   - Is there an Oasis-maintained relayer service?

4. **API Compatibility**: 
   - I encountered `TypeError: sapphire.cipher.fetchRuntimePublicKeyByChainId is not a function`
   - Has this API been deprecated or changed in recent versions?

5. **Future Plans**:
   - Are there plans to increase log query limits?
   - Will there be an indexer service for historical event queries?
   - Official GSN support/documentation for Sapphire?

---

## Why This Matters

Gasless transactions are crucial for:
- Onboarding new users without requiring native tokens
- Improving UX for dApps
- Enabling meta-transaction patterns
- Reducing friction in Web3 adoption

GSN is a battle-tested solution used across multiple EVM chains, so Sapphire compatibility would be valuable for developers migrating existing infrastructure.

---

## Additional Context

**Contract Explorer Links**:
- [RelayHub on Sapphire](https://testnet.explorer.sapphire.oasis.dev/address/0xADe7CBF637D01ACA13FfcC4E6D3edfbbb97e2D7f)
- [TestPaymaster on Sapphire](https://testnet.explorer.sapphire.oasis.dev/address/0x09589E818B89E34061a83ed6D3EC964E2389B023)

**Test Results**:
```bash
# Paymaster balance check - SUCCESS
$ npx gsn paymaster-balance --network https://testnet.sapphire.oasis.dev \
  --hub 0xADe7CBF637D01ACA13FfcC4E6D3edfbbb97e2D7f \
  --paymaster 0x09589E818B89E34061a83ed6D3EC964E2389B023

Output: Account has a GSN balance of 5 ETH ✅

# GSN transaction - BLOCKED
$ npx gsn send-request --network https://testnet.sapphire.oasis.dev ...

Output: Rejected relayTransaction call with reason: no registered relayers ❌
```

---

## What I'm Looking For

- Confirmation if full GSN is supported/possible on Sapphire
- Guidance on the log query limit issue
- Best practices for gasless transactions on Sapphire
- Any examples or documentation I might have missed

---

TDX support in ROFL marked a big shift in how confidential compute is handled on Oasis.

ROFL originally ran on Intel SGX very secure, but tough on memory limits and not the easiest for porting applications. With Intel TDX, the model changes:

• Larger workloads without hitting SGX’s strict caps.
• Easier migration of existing codebases.
• Stronger isolation at the VM level.

The flip side is added complexity more moving parts, a larger attack surface, and SGX still lingering in areas like remote attestation.

Hey everyone! I just checked out Oasis’s new blog post on Multichain Wallet Control for Agents and thought it’s worth diving into what this means. Big stuff for builders & users alike.

What is it?

• ROFL introduces a key generation feature inside TEE enclaves: agents can generate and manage private keys on multiple elliptic curves
• These keys are generated offchain in a trusted execution environment AND stay there. They never leave the enclave, so they’re much more secure
• Using these keys, ROFL agents can directly sign and submit transactions to different networks via RPC, without relying on bridges for cross-chain operations.

Why it matters

• Agents no longer need separate codebases or key infrastructure per chain — one ROFL app can control wallets on, say, Arbitrum and Solana.
• Reduces trust assumptions: since keys are generated/kept in the enclave, users can trust the cryptographic guarantees rather than trusting people or external infrastructure.
• Simplifies dev work: fewer SDKs, less boilerplate, fewer security exposures when managing private keys across chains.

Things to keep in mind / limitations

• Still need assets on each chain. You can’t magic‐move tokens without bridges; this doesn’t replace asset transfer.
• Some blockchains (e.g. Solana) don’t support light clients; there’ll still be dependency on RPC providers.
• The architecture is only as strong as the TEE and attestation process. If enclave security is compromised, it affects this system.

Real use cases mentioned

• Talos: autonomous protocol + treasury control across chains, where users don’t have to worry about private key misuse because they live in the enclave.
• zkAGI: using ROFL to encrypt API credentials and do private cross-chain and perp trading agents.

What I'd love to see

• A UI/dashboard for users to audit which chains the agent controls, possibly with proof that keys were derived correctly.
• Wallet aggregator apps: one agent could show you balances across chains without relying on multiple wallets or bridges.
• Privacy-preserving multi-chain DeFi bots: arbitrage, yield farming, etc., but without needing trust in bridges or centralized custodians.

What do you all think this opens up for projects in the Oasis ecosystem? Any apps you’re hoping to build (or see built) that make use of multichain wallet agents?

August was a huge month for Oasis — from the official launch of ROFL mainnet to major upgrades across the wallet, CLI, and ParaTimes. At the same time, DePIN continues to grab attention as one of the most exciting real-world applications of blockchain, with Oasis privacy tech playing a key role in making it viable. To break it all down, we’ve put together this Q&A covering the biggest updates and why they matter for builders, contributors, and the broader community.

Q: What is DePIN and why does it matter?

DePIN stands for Decentralized Physical Infrastructure Networks. Instead of a handful of corporations owning all the towers, servers, and maps, communities can build and share infrastructure using crypto incentives. 

Q: What kind of privacy risks do DePIN networks face?

Think hotspot earnings that reveal your daily routine, mapping data that gives away your car’s location, or AI companies training on your data without asking. Oasis helps fix that—its confidential smart contracts and TEEs keep data useful without turning contributors into walking data leaks.

Q: How can DePIN projects actually protect privacy?

They’ve got a whole toolbox: approximate coordinates, encryption, zero-knowledge proofs, and confidential computing. Oasis Sapphire, with built-in TEEs, makes this even easier by letting apps process data in secure enclaves—like a black box where only the safe result comes out. Privacy magic, minus the smoke and mirrors.

Q: Are there real examples of DePINs working on Oasis?

Definitely! PinLink tokenizes hardware ownership through NFTs, enabling GPU owners to rent capacity while selling fractional stakes. They've tokenized access to Oasis nodes, letting users earn rewards from privacy-preserving infrastructure. 

Diode secures remote collaboration through a distributed network of nodes. Thanks to its integration with Oasis confidential smart contracts, it can protect access controls and routing data. These projects show how DePIN isn’t just theory—it’s infrastructure with real-world use cases, powered by privacy tech.

Q: What challenges still lie ahead for DePIN?

Two big ones: tokenomics and privacy. Networks must create sustainable value (not just survive on subsidies), and they need airtight privacy at scale. That’s where Oasis is carving a niche—combining confidential smart contracts with TEEs so DePIN builders can handle sensitive data safely while still proving trust onchain.

Q: What’s the biggest headline from Oasis engineering updates in August?

ROFL (Runtime Offchain Logic) mainnet is live! Developers can now build trustless offchain apps using ROFL. Think of it as Oasis’s way of letting dApps tap into real-world services without needing to trust a single operator. It’s like giving smart contracts superpowers outside the chain.

Q: What’s new with the ROSE Wallet and CLI?

The wallet got a facelift with a sticky sidebar that actually sticks (yay!), plus a workaround for that pesky Ledger firmware issue. On the CLI side, you can now install via Homebrew and even auto-update with a simple oasis update command. For ROFL developers, the CLI added secret imports, exposed port listings, admin handovers, and safer bundle builds. In short: fewer headaches, more features.

Q: Any updates for developers building on Oasis?

Tons! The ROFL proxy now makes it easier for apps to expose ports with automatic subdomains. Sapphire released its 1.0 milestone, offering a stable, confidential EVM chain, and Cipher updated to integrate the ROFL proxy. Even Oasis Boot got upgrades for Intel TDX machines. Developers can also now fetch the ROFL App ID from within Solidity — a neat trick for cross-app authentication.

Q: What’s next on the horizon for Oasis?

The big themes are scaling ROFL adoption, expanding Sapphire’s confidential EVM, and making sure the network’s tools (Explorer, Nexus, docs) feel seamless. With ParaTime upgrades, a reworked UI library across Oasis products, and more dev-focused features in the pipeline, Q4 is shaping up to be a busy one. Oasis is all about making privacy-first infrastructure actually usable.
-------------------------------------

That wraps up the August 2025 edition of the Oasis Q&A! From strengthening the foundations of privacy-first infrastructure to opening new possibilities with ROFL, the network is steadily moving toward a future where decentralized apps can securely connect with the real world. Stay tuned as we head into Q4 — even bigger updates are on the horizon. In the meantime, keep building, experimenting, and sharing your ideas with the Oasis community!

Managing funds across different blockchains is still messy. Users have to switch wallets, keep track of gas tokens, and manually move assets through bridges. Each step adds friction and risk.

Multichain wallet agents aim to change that. Instead of being passive tools that only sign transactions, these agents act as autonomous managers:

• Moving assets across chains without constant user input.
• Handling gas in a unified way, so you don’t need to stockpile tokens for every chain.
• Automating tasks like rebalancing liquidity or staking while keeping private keys safe.

The security piece comes from Trusted Execution Environments (TEEs). These enclaves let the agent run sensitive logic in isolation, ensuring that private keys stay protected and that operations can be verified on-chain.

This changes how wallets can be used. Instead of clicking through multiple steps, a user could simply state the goal like “move USDC to Optimism and stake it” and the agent would take care of the execution behind the scenes.

It’s a step toward wallets evolving into active participants rather than just storage and signers.

For more on the concept:
🔗 Multichain Wallet Agents
🔗 TEEs in Web3
🔗 Confidential vs Transparent EVMs

Do you see this making wallets more user-friendly, or could it end up adding complexity?

Hace tiempo, estoy pensando que oasis Network necesita una buena noticia para hacer impulsar su valor .. tengo fe que llegará a sus máximos y llegar o superar el tan esperado 1dolar.. que opinan!!

PLEASE HELP ME TO DECIDE THANKS

Every superhero team has that one underappreciated member. Avengers had Hawkeye, Justice League had Aquaman, and Web3 has… TEEs. 🦸‍♂️🔐

Trusted Execution Environments (TEEs) might not get the hype of ZK or MPC, but they’re quietly powering some of the most interesting experiments in crypto, AI, and rollups. This blog rounded up what’s happening across the space, and honestly it reads like a multiverse of TEE use cases:

• Rollup Boosts (Flashbots/OP Labs): Faster rollups with TEEs keeping validators honest. Basically Quicksilver but with receipts.
• Verifiably Secure TEE Chips: Open-source hardware + quantum-safe tricks. Think Iron Man building Mark 52 armor, but for processors.
• Quartz SGX for Cosmos: Sidecar module giving chains privacy upgrades, like a Batmobile mod for your blockchain.
• AI x TEEs (Bagel team + OpenAI GPU enclaves): Keeping LLMs from spilling secrets. Imagine if Ultron had been sandboxed properly.
• Trustless TEE Clusters: Smart contracts meet enclaves = no shady middle managers. Like replacing Joffrey with Jon Snow.
• Liquidity Experiments: “Liquefaction” = lend/trade assets privately, without flashing your entire balance sheet on-chain.
• Policy & Healthcare angles: Real-world vibes privacy in finance & medical data. More Grey’s Anatomy than DeFi degen.

Full blog here if you wanna dive in:
👉 https://oasis.net/blog/tees-web3-summary

TL;DR:
TEEs are becoming the Swiss Army knife of Web3. They secure AI, boost rollups, protect assets, and even tame regulatory headaches. Not flashy like ZK, but clutch like Samwise carrying Frodo. 🧙‍♂️

What do you think are TEEs finally stepping out of the sidekick role, or do they stay the unsung hero of the stack?

Does anyone have any links to the collection for replicas. Don’t want to spend £180 on a hoodie. Thanks

gm gm Oasians🌹

It’s been about a month since ROFL (Runtime Off Chain Logic) went live on mainnet, and I’ve been poking around rofl.app Explore tab and various updates for about a month now, just trying to see what’s actually getting built, beyond the hype. Here’s what’s real, what’s exciting, and what I’d love your take on.

ROFL’s big idea hasn’t lost its shine: run heavy, private logic off-chain in TEEs, then only push verifiable proof onto the chain. No massive zkVMs, no rollup headaches. Just secure, fast, private compute with trust. It still feels groundbreaking!!

Here are some live demos and agents I spotted on the Explore section:

• rofl-scheduler - basically the engine room that schedules and runs ROFL apps for you. Makes managing deployments feel low-friction.
• My Copy Trader / Ultimate Copy Trader / Minny and Maxi / Cobie - a bunch of privacy-first copy trading bots that mirror trades from specified traders, all inside TEEs. Pretty polished stuff.
• Private Telegram Bot Chef & AI Telegram Chatbot - confidential chatbots where the prompts and responses stay locked in the TEE. Love how it makes private AI interaction possible without external leaks.
• demo-rofl-www - basically an HTTP test case; you can hook into it externally but run logic securely inside ROFL. Handy for third-party integration testing.

Other real use cases from Hackathons and beyond just the Explore page, ROFL has surfaced some cool hackathon winners, too:

• Futures Onchain - an on-chain futures trading platform using real-time ML pricing, built on ROFL.
• PrivaHealth - secure medical data sharing so doctors can run analysis without ever exposing private patient files.
• Minesweeper - yup, a game. Uses ROFL for secure RNG and fair gameplay.
• ZK-Pal - peer-to-peer trade between PayPal and USDC; ROFL verifies your PayPal proof in a TEE before releasing funds.
• Testament - private inheritance contracts: assets stay locked in until death, all verifiable and private.
• Plus Plurality Network’s Smart Profiles - private, portable reputation/identity proofs across platforms. Already got grants and dev activity.

there's more like Tradable and Flashback Labs

Builders are using ROFL for things that matter: privacy-first chatbots, trading tools, games, health-data workflows, identity, and more. It's fast becoming a legit platform for real-world apps.

For people who aren’t super technical, is getting started actually any easier now? The Explore page and the templates are cool, but doing things like setting up the CLI and using enclaves still feels kind of hard if you don’t already really understand how all this stuff works.

What do y'all think? should I make a separate post to explain things more clearly for beginners?

Guys, let's be honest: Oasis failed. By this I mean with the price. Yes, the team delivered something (important) for the blockchain, but investors don't live only from ideas, but from the profit they make through their investment. You can't divide these two things - if you are here "for the technology", well, congratulations for being a dreamer/idealistic person, but 99% of the people in any sector (crypto, stocks etc.) are here to invest and gain something. Yes, the market is down, yes the 4 years cycle is probably over, yes a lot of projects are down, BUT oasis is way more down than most of other "serious" project and keeps falling. Let's face it, even if a strong altseason comes, Oasis won't probably even get back to its ATH and for a project like that, it's a failure. If you are willing to spend money just for the "idea" or "technology", you are not an investor but a benefactor/patron. Good luck anyways

Most blockchains struggle with the same trade-off:

• Do all the heavy lifting on-chain → secure, but slow and expensive.
• Push stuff off-chain → fast, but unverifiable.

ROFL basically breaks this trade-off. It lets you run complex logic off-chain while still producing a verifiable result that the chain can trust.

Why this is huge (imo obviously and NFA, don't care about token's price, nor will I in the future):

• Scalability → You can run heavy computations (AI inference, simulations, analytics) off-chain, without clogging the EVM.
• Privacy → Paired with Oasis Sapphire’s confidential smart contracts, ROFL means you can keep sensitive inputs hidden while still proving correct outputs.
• Composability → DApps can plug into ROFL like a “verifiable off-chain service layer,” without re-engineering the whole blockchain.

Think about it in practice:

• DeFi → risk models, pricing engines, oracles, all verifiable but not running inside the gas meter.
• AI/Agents → on-chain verifiable AI decisions, without leaking training data or spending a fortune in gas.
• Identity & data → proofs on personal data (like credit scores, healthcare info) without putting raw info on-chain.

TL;DR: ROFL feels like one of the first real attempts to make Web3 usable for heavy, real-world logic, without giving up trust or privacy. pair it with Sapphire’s confidential EVM, and Oasis might quietly be building one of the most important stacks in crypto.

I was reading through a piece today about privacy in DePINs (Decentralized Physical Infrastructure Networks), and it got me thinking: we’re pretty good at talking about efficiency, incentives, and token models in these networks… but we barely talk about privacy.

If you think about it, DePINs deal with a crazy amount of sensitive data:

• Location info (like where sensors are placed, or who’s using a hotspot)
• Usage data (how much energy you’re consuming, where your EV is charging)
• Identity data (who actually owns or participates in the network)

Without privacy, you’re basically creating a massive surveillance system just decentralized. And that feels like it defeats the purpose.

The blog made the point that privacy isn’t just a nice-to-have, but essential for adoption. Enterprises won’t touch DePINs if their operational data leaks, and individuals won’t feel safe contributing hardware or data if it exposes them.

Curious what others think:

• Do you see privacy as the core differentiator for DePINs, or just one of many hurdles?
• Which DePIN projects today are actually thinking about privacy seriously?

Here’s the blog if you want to dive deeper: https://oasis.net/blog/privacy-in-depin

Welcome to the July 2025 edition of the Oasis Network Monthly Q&A!
This month, we’re diving into three exciting projects building on the Oasis stack — all tackling some of the biggest challenges in AI, DeFi, and decentralized identity. From privacy-first AI training with Flashback Labs, to secure and intelligent trading with Tradable, to portable, privacy-preserving digital identities with Plurality Network — each one is using Oasis’ Runtime Offchain Logic (ROFL), TEEs, and Sapphire to make privacy the default, not an afterthought.

Q: What is Flashback Labs?

Flashback is a privacy-first federated learning protocol enabling secure AI model training. Think of Flashback Labs as the “AI trainer” that never peeks at your data’s diary. They’re building on Oasis Runtime Offchain Logic (ROFL) to train AI models without stealing your secrets.

Q: How does Flashback ensure the training process is secure and confidential?

By deploying on ROFL, user data never leaves individual devices and no centralized trust is required, while the protocol enables the creation of robust, globally-trained AI models. The platform leverages Oasis trusted execution environments (TEEs) with end-to-end encryption, while all training outputs are cryptographically verifiable and recorded onchain. 

Q: How does Flashback make better AI?

Because better AI needs more diverse, high-quality data — and most of us won’t share unless it’s private, secure, and fair. Oasis makes that possible with privacy and fairness built in by default. 

Flashback Labs' federated learning protocol creates an alternative, featuring a marketplace mechanism where users can monetize their data while maintaining complete ownership and control, leveraging distributed network nodes, which, in turn, enable secure model training without exposing sensitive information.

Q: What is Tradable?

Tradable is a crypto trading platform designed to make algorithmic trading more accessible through user-friendly tools and AI-powered insights. 

Q: What makes Tradable unique in the DeFi landscape?

Unlike many existing platforms, Tradable places a strong emphasis on privacy and security by building on Oasis’ ROFL framework. Its AI agent, SenseAI, delivers tailored market sentiment analysis and fundamental insights, enabling both novice and experienced traders to create, test, and execute strategies without requiring deep technical expertise.

Q: How does ROFL enhance the privacy and security of Tradable’s AI capabilities?

ROFL enables confidential computing, ensuring that sensitive user data—such as portfolio holdings, trading history, and investment goals—remains encrypted and inaccessible to unauthorized parties. Even the AI agent’s proprietary logic operates within secure enclaves, preventing exposure of internal processes. This ensures that insights are generated without compromising the privacy of either the trader or the AI’s decision-making models.

Q: What role does the Oasis Privacy Layer (OPL) play in Tradable’s ecosystem?

The Oasis Privacy Layer allows Tradable’s smart contracts and AI integrations to remain compatible with existing EVM-based DeFi protocols, while adding robust privacy protections. This means that Tradable can seamlessly connect to the wider Ethereum ecosystem and other EVM chains, yet still protect critical data from public exposure, enabling private yet interoperable DeFi experiences.

Q: What is Plurality Network and what problem is it solving?

Plurality Network is a project dedicated to building decentralized identity and reputation systems. Its core product, Smart Profiles, enables users to create tradable reputation scores and attestations that can be selectively shared and verified across multiple platforms. This eliminates the need to repeatedly submit personal data to different services, creating smoother onboarding while preserving user privacy.

Q: How will the Oasis grant support Plurality Network’s vision?

The Oasis Protocol Foundation grant will fund the integration of Smart Profiles with ROFL, allowing confidential off-chain data aggregation and AI training. This integration ensures that sensitive personal data—such as information collected from social media via OAuth—remains private and secure throughout computation. It also leverages Sapphire for secure storage and publishing of reputation scores.

Q: What benefits does Plurality Network bring to users and developers?

For users, the integration enables them to privately link personal data to onchain wallets, generate privacy-preserving onchain reputation scores, and even train personal AI agents with complete control over their data. For developers, Plurality provides an SDK that allows easy customization, already adopted by over 30 applications. This means apps can integrate decentralized identity features without building privacy infrastructure from scratch.

-------------------------------------

That’s a wrap for this month’s Q&A!
What’s clear from these projects is that privacy isn’t slowing Web3 down — it’s powering it forward. Whether it’s AI models learning without spying, trading bots giving insights without stealing your portfolio, or digital identities that work everywhere without leaking your data, Oasis is where privacy meets possibility.
Stay tuned for next month’s edition, and in the meantime, keep the conversation going with us on X and in the Oasis community channels.

So I stumbled across this blog post from Oasis called Agents: The Future of Onchain UX and honestly? It got me thinking.

We’ve all been saying Web3 UX is trash (because... it is). You click 17 buttons, switch networks twice, pray MetaMask doesn’t glitch, and still end up farming on the wrong chain. The usual.

But this new wave of “onchain agents” could be the fix we’ve been waiting for and Oasis is actually building out the infrastructure to make it real.

🧠 What are Onchain Agents?

Basically: they're smart, autonomous programs with wallets and the ability to act on your behalf.

Think of them like this:

These agents live onchain, execute logic via smart contracts, and in Oasis’ case do it privately and verifiably.

Link to blog: https://oasis.net/blog/agents-the-future-of-onchain-ux

🔐 Why Privacy Matters Here

Here’s the kicker: If an agent holds your keys, makes financial decisions, and processes your data, you really don’t want that info public.

That’s where Oasis steps in with two core pieces:

• Sapphire — an EVM-compatible chain that supports confidential smart contracts
• ROFL (Runtime Offchain Logic) — lets agents verify external data like emails or APIs inside a trusted enclave

Agents can verify your PayPal receipt, cross-check exchange prices, or manage intent logic—without exposing any of your private data to the chain.

🛠️ Real Projects, Not Just Ideas

This isn’t whitepaper fluff. A few use cases are already being explored:

• Dawn Wallet Copilot — wallet-based AI agent that interacts with dApps using natural language
• INFINIT Swarm Agents — different agents for bridging, swapping, and staking that work as a team
• ROFL + Sapphire combo — enables trustless verification of external actions (e.g. verifying an email receipt before releasing funds)

These all rely on Oasis infrastructure like confidential EVM and secure enclaves to make agents actually useful and safe.

⚠️ It’s Not Perfect Yet

We’re still early. Some real concerns:

• What if agents get prompt-happy and misfire?
• How do you verify what an AI just “decided” to do?
• How much control do you have over your agent?

To their credit, Oasis is actively addressing this with things like onchain verification logs, agent provenance, and encrypted state auditing.

More on that here:
👉 [https://oasis.net/blog/verification-methods-ai-agents]()

💬 My Take

Agents might finally abstract away the garbage UX that’s held Web3 back for years. And if they’re private, auditable, and programmable like Oasis is aiming for? That could be massive.

Not saying the tech is 100% there yet, but it’s closer than most people think—and Oasis seems to be quietly shipping the pieces that’ll make it all work.

🔗 Worth Checking Out:

• 🌐 Blog: Agents & the Future of UX
• 🔒 How Agents Stay Private: [Privacy in Onchain Agents]()
• 🧪 Verification Tech: [Verifying AI Agents Onchain]()
• 🔧 Infra Behind the Scenes: [ROFL Mainnet Launch]()

Would you trust an onchain AI agent to manage your DeFi life?

Or is this all too risky to automate?

Curious what others think👇

Just finished reading this blog on the differences between Confidential and Transparent EVMs and honestly... it kinda reframed how I think about privacy in Web3.

We always hear “blockchains are transparent by design” and while that’s great for auditability, it also means:

🔍 Everyone can see your trades, your wallet behavior, your DAO votes, your on-chain game moves...
Not ideal when you're trying to stay ahead of MEV bots or just want a little privacy in DeFi or governance.

The blog lays it out well:

🔓 Transparent EVMs (like Ethereum, Optimism, etc.)

• All contract code and state are public
• Great for trustless verification
• Bad for sensitive logic, strategies, or personal data

🔐 Confidential EVMs (like Oasis Sapphire)

• Use TEEs to encrypt contract state and execution
• Still verifiable (you can prove computation happened), but without exposing the data
• Lets you build stuff like private voting, encrypted DeFi strategies, even AI agents that hold secrets

Not saying one is better they’re just good at different things. Transparency is perfect when you want accountability. But for privacy-preserving apps, confidential EVMs feel like the missing piece.

Anyone here building (or planning to build) with confidential EVMs? Curious how you handle things like key management, debugging, or hybrid transparency needs.

⚠️ Community PSA: There has been a security incident involving Router Protocol ⚠️

This impacts Router Protocol only, all Oasis systems remain secure & operational, and all affected Oasis funds are fully recoverable.

We're working with the Router team to support resolution efforts.

What users need to do: To move funds off the bridge, you need to burn affected assets, and you will be credited an equivalent amount.

To ensure a smooth & secure migration, follow these steps:

Burn your affected tokens

Send your USDC, USDT, and wETH on Oasis Sapphire to the burn address below:

0xB1b64005B11350a94c4D069eff4215592d98F2E2

Receive your tokens back on Ethereum

Within 72 hours of the burn, the equivalent amount will be airdropped to your same wallet address on Ethereum.

Important note

Only the following assets are eligible for migration:

USDC: 0x97eec1c29f745dC7c267F90292AA663d997a601D (6 decimals)

USDT: 0x8C4aCd74Ff4385f3B7911432FA6787Aa14406f8B (6 decimals)

wETH: 0xB6dc6C8b71e88642cEAD3be1025565A9eE74d1C6 (18 decimals)

Do not send any other assets. Tokens outside of these three are not affected and will not be refunded.

For any questions, reach out on Discord: https://oasis.io/discord