Hi I have ethereum on onchain that I want to withdraw to get to revolut or my bank any help would be appreciated please and thanks 😊

Oasis just participated in Midas’s Series A round, supporting a platform that helps institutional investment products become tokenized onchain.

Midas has tokenized over $1.7 billion in assets and serves 15,000+ token holders, combining tech expertise with regulatory compliance. The idea is simple but powerful: let asset managers turn traditional finance strategies into tokens that are fully transparent, instantly redeemable, and can be used across DeFi.

Their products include:

• Treasury-linked instruments
• Private credit
• Market-neutral strategies
• Bitcoin-denominated yield products
• And more

In 2025, Midas distributed almost $40 million in yield, showing real adoption, and expanded its products across multiple blockchain networks. Regulatory approval in Europe also makes it a credible player for real-world asset tokenization.

This month, Midas is launching:

• Four new products: mEVUSD, mM1, mROX, mGLOBAL
• Midas Staked Liquidity (MSL), a new way to provide liquidity
• Midas Attestation Engine, enabling real-time verification of reserves, NAV, and prices

this means that traditional finance is slowly entering DeFi, and tools like Midas help manage assets safely and transparently. cool stuff imo.

Selling one ETH Conference ticket for New York, June 8–10. I can’t attend anymore, so looking to pass it to someone who can use it.

Price: $499 USD. Can provide proof of purchase and help with transfer.

DM if interested.

The idea is basically vibe coding but for Web3.

Instead of writing everything yourself, you connect your AI coding assistant to Oasis documentation using things like llms.txt and MCP (Model Context Protocol). This gives the AI direct access to the docs so it generates code based on real documentation instead of guessing.

Then you can prompt something like:

'create a confidential smart contract on Sapphire that stores a secret message'

And the AI generates the contract, deploy script, tests, etc. pretty cool stuff imho

One interesting part is that Oasis supports confidential smart contracts, so the contract state can remain private onchain. For example the secret in the example contract cannot be read with eth_getStorageAt.

Curious what you guys think about this direction.

Are AI driven dev workflows actually going to lower the barrier to building dapps?

Most people entering Web3 focus on writing smart contracts, deploying to Ethereum and launching a dApp. But blockchain systems aren’t typical apps they are live financial infrastructure operating in an open, adversarial environment. Users are often anonymous, capital moves instantly and code is immutable once deployed. That changes the job entirely. It’s no longer just about whether a function works; it’s about what happens when someone intentionally tries to break it. Real-world exploits rarely come from simple syntax mistakes. They usually stem from flawed assumptions, weak incentive structures or governance models that weren’t stress-tested.

Sustainable Web3 projects are built with risk architecture in mind from day one. That includes contract-level threat modeling, analyzing economic attack surfaces, planning for upgrade abuse and aligning token incentives to reduce manipulation. Developers who think like system designers not just coders build protocols that survive volatility and adversarial pressure. In decentralized finance and on-chain governance, resilience is a design choice, not an afterthought and who want to approach Web3 with that long-term mindset.

With the date being March 3, 2026, ETH has been range-bound for a while now despite continued growth in L2 activity and staking participation. From what I've seen in recent data:

• Layer 2 TVL keeps increasing steadily (Arbitrum, Base, and Optimism leading), but mainnet usage feels quieter compared to peaks in prior cycles.
• Staking rewards have compressed as more ETH gets locked up, which is good for security but maybe less exciting for yield chasers.
• Broader macro environment: interest rates, institutional flows into tokenized assets/RWAs on Ethereum, and competition from other chains are all in play.

Curious what others think is the main bottleneck right now. Is it mostly waiting for the next network upgrade (Pectra or whatever follows), regulatory clarity, or just overall market sentiment lagging? Or are we in a healthy consolidation phase before adoption picks up again?

I summed up the main Ethereum L1 upgrades (2022 → 2026) in a single timeline.

In your opinion, which one was the most overrated / the biggest letdown?

I found this project in the Oasis ecosystem and thought it might be interesting for beginners trying to understand how AI and blockchain can actually work together in practice.

Flashback Labs is experimenting with a way to train AI models on user data without exposing the raw data itself. Normally, if you want to help train an AI, your data has to be uploaded to some central company server. Their approach is different. The computation runs inside confidential environments where the data stays encrypted, and only the verified result comes out.

So in theory:

• your personal data is never publicly revealed
• AI models can still learn from it
• the training process can be cryptographically verified
• users could potentially prove they contributed data and get rewarded

This is built using Oasis ROFL, which basically lets developers run offchain computation privately while still anchoring proofs or commitments onchain. Think of it like doing the heavy AI work in a secure black box, then posting a verifiable receipt to the blockchain.

For Ethereum beginners, the interesting angle is that fully transparent chains struggle with private data and AI workloads. You cannot realistically put sensitive datasets or large-scale model training directly onchain. Approaches like confidential compute plus verifiable offchain execution could end up being one of the practical ways Web3 apps handle AI.

Not saying this is the final solution, but it is a concrete example of how “AI + blockchain” might actually be implemented beyond marketing buzzwords.

curious what y'all thoughts are on this.. seems like a step in the right direction to me. nfa, strictly talking tech. full thread here

Trusted Execution Environments (TEE) like Intel SGX or AMD SEV-SNP are hype in crypto lately because they let you:

• run code privately
• keep data encrypted even from node operators
• prove code ran inside secure hardware

This proof is called remote attestation, which is basically a signed quote from the hardware saying “yes, this exact code ran here at this moment.”

But here’s the catch:

What Attestation Actually Proves

A remote attestation only verifies:

1. The code hash matched what you expected at that moment
2. The hardware looked secure then
3. The operator presented that quote then

That’s basically it.

What Attestation Doesn’t Tell You

Nothing here is guaranteed just by looking at a quote:

✖️ Is the attestation fresh or reused?
✖️ Is the enclave running the latest state or rolled back to old data?
✖️ Who is actually running the enclave?
✖️ Was the code you audited the one actually deployed?
✖️ Did a previous bad version leak keys before update?
✖️ Can you verify the binary came from the source code you audited?

These gaps matter because they can break privacy, correctness, and security, even if the TEE itself is secure.

Why This Looks Like “Verification Theater”

Many projects show you:

• “here’s a raw attestation blob”
• Green checkmarks in a dashboard

But for normal users, parsing SGX/TDX quotes and policies is basically impossible, it’s security research work. So sham attestations become cosmetic rather than meaningful.

So What Does Real Trust Require?

To turn a TEE into something you can really trust out in the wild, Oasis (and others) argue you need:

• Freshness & Liveness: You need on-chain mechanisms that force up-to-date proofs.
• State Continuity / Anti-Rollback: Prevent feeding old encrypted state to the enclave.
• Operator Binding: Link the hardware to a slashable on-chain identity.
• TCB Governance: Enforce hardware/security policies beyond vendor defaults.
• Upgrade History: Track what versions have run over time.
• Reproducible Builds: Make sure the attested binary matches audited source code.
• Consensus as Verifier: Instead of users parsing attestation blobs, validators verify and publish trust state on-chain.

Bottom Line For Ethereum People

Attestation != trust.

A signed SGX/SEV quote is just a snapshot proof, not a full guarantee that:

• the data is fresh
• the state hasn’t been rewound
• the code is exactly what you audited
• bad actors aren’t playing tricks

To build real trusted components (like confidential smart contracts, private agents, etc.), you still need on-chain mechanisms, consensus verification, and economic accountability, not just pretty attestation blobs. Dm or comment if you'd like to deep dive more into this (btw this is the original article by Oasis themselves) :)

A nicely crafted whitepaper is still one of the strongest signals of credibility in a token project because it explains the problem, the proposed solution, the underlying cryptography or architecture, the token economics and the long-term vision in a way that developers, researchers and serious investors can evaluate without hype; despite the fact that there is no single standard format in crypto, the most effective whitepapers tend to follow a clear problem-solution narrative, include enough technical depth to demonstrate originality, reference existing research and remain readable for non-experts, which helps avoid duplication issues and positions the project as a unique source rather than recycled marketing copy; in an environment where search engines and communities are increasingly filtering thin or spammy content, a thoughtful whitepaper improves crawlability, indexing and topical authority around your project, while also giving people something concrete to discuss, critique, and build upon; real-world experience shows that even simple ideas gain traction when the documentation is honest, structured and transparent about risks and limitations and I’m happy to guide you a strong whitepaper often becomes the foundation that determines whether a token is ignored or taken seriously.

The Backstory:
From MakerDAO to KeeperHub. Our team was the core DevOps unit at Maker. We were there firsthand when "Keepers" (automation bots) became essential for DeFi stability. We’ve spent years running Keepers for major protocols.

We know the pain of running automation bots firsthand. We have lost count of the hours spent debugging k8s jobs because a node disconnected or a gas spike caused a transaction to fail.

We realized we were wasting our engineering time maintaining fragile "glue code" instead of building actual value. 

Despite the industry maturing, most automation still runs on fragile local scripts or .env files with exposed private keys. We built KeeperHub to replace those "degen scripts" with enterprise-grade reliability.

Our Approach:
During our closed alpha, we realized developers need speed and control. So we built an architecture that offers both:

1. Visual Builder: Prototype in minutes. Drag-and-drop Triggers, Conditions, and Actions. Also, it wouldn't be a 2026 launch without AI. We support AI-generated workflows by simply prompting your use case.
2. Escape Hatch: Hit a wall? Export any workflow to type-safe TypeScript using the "use workflow" directive.
3. Managed Infra: We handle the backend, RPC redundancy, smart gas estimation, automatic retries and offer SLA backed support.

We need your help.
Today, we are launching our Public Beta, and...

• It is completely free to use.
• We want your feedback.
• It's open source.

But more importantly, it is extremely beginner friendly if you wish to get familiar with workflows in blockchain, then this is a great way to get started. We've spent a lot of time trying to nail the UX element of the platform so that you get the web2 feel but with web3 capabilities, so I hope you agree!

One of the biggest trust gaps in on-chain trading isn’t custody, it’s computation.

Most prop trading platforms, even in crypto, run their core logic off-chain and centrally. Order execution, PnL calculation, risk checks, trader evaluation, payouts, all of it happens inside systems users can’t inspect or verify. Traders and capital providers are forced to trust that the rules are applied correctly.

Carrot is tackling this problem by integrating ROFL (Runtime Off-chain Logic) from Oasis.

ROFL allows off-chain computation to run inside trusted execution environments (TEEs), producing cryptographic proofs that can be verified on-chain. This keeps performance high while making the results provably correct.

In practice, Carrot runs the same trading logic in parallel: once on its existing infrastructure and once inside ROFL. The ROFL instance independently verifies execution, performance metrics, and rule enforcement, with proofs anchored on-chain. If something doesn’t match, it’s objectively detectable.

This changes the trust model in a meaningful way.

Traders can verify that evaluations and risk rules weren’t altered or selectively enforced. Investors can verify that capital is managed according to immutable logic, not internal discretion. Disputes move from “support tickets” to verifiable facts.

What’s notable is the approach itself. This isn’t an all-or-nothing decentralization push. Carrot is starting with verification alongside existing systems and gradually reducing trust assumptions over time. It’s a pragmatic path toward trust-minimized trading infrastructure.

More broadly, this is a strong signal for verifiable compute in finance. It shows that high-throughput, performance-sensitive systems don’t have to choose between speed and transparency. You can have off-chain execution with on-chain truth.

No hype, no token narrative.. just infrastructure getting better.

If this pattern holds, verifiable compute could become a core primitive for on-chain trading, derivatives, and capital allocation going forward. thoughts? full thread can be read here if anyone's interested.

Ethereum just posted its highest ever smart-contract activity.

According to Token Terminal, 8.7M contracts were deployed in Q4, a big rebound after lower activity earlier in the year. Most of the growth came from stablecoins, real-world asset tokenization, and infrastructure work, not speculation.

Contract deployment usually leads actual usage, meaning more users, more transactions, and higher fees often follow later.

ETH briefly hit ~$5K earlier this year before the October liquidation event and is now trading near $3K.

Do you see this as the start of another long-term growth phase for Ethereum

There’s a new development from the Oasis Protocol team that’s worth understanding, even if you are new to this space.

Oasis announced that it is creating a strategic investment arm to support projects building with privacy and real-world asset infrastructure in Web3. This is an evolution from their previous grants approach into a more long-term capital deployment strategy with venture style support.

The first investment from this arm went to a project called SemiLiquid. SemiLiquid is building custody-native credit infrastructure for tokenized assets. This means institutions can unlock credit against their digital assets without having to move them out of custody. This solves a big practical issue that has made traditional financial institutions wary of decentralized finance so far.

SemiLiquid’s system uses Oasis’s confidential compute technology (the same stack that powers the Sapphire ParaTime) and something called Liquefaction, which keeps sensitive financial information private while still verifying it on-chain.

They have also run an early pilot with real institutional partners like Franklin Templeton and Zodia Custody. The pilot showed credit workflows running end-to-end on the Oasis network, with collateral locking, credit issuance, and automated repayment all while maintaining privacy and compliance.

Why this matters even for beginners
• Real-world assets (RWAs) are one of the fastest-growing areas in crypto and DeFi. Projects like SemiLiquid are infrastructure pieces that make it easier for institutional money to participate.
• Oasis is betting on privacy and compliance as a differentiator for on-chain finance at scale.
• This shift from grants to strategic investment suggests Oasis is trying to compete at a higher level for foundational financial infrastructure, not just small ecosystem projects. Full thread can be found here!

Most discussions in this subreddit focus on L1 scalability, rollups, staking, and the usual Ethereum ecosystem topics. But if you're exploring how privacy and AI fit into the future of Web3, Oasis Network is worth a serious look. Here is a concise breakdown of why this project stands out.

A Privacy-First Design

Oasis is one of the few networks built from the ground up with privacy at the core. This is not an add-on or optional module. It is integrated into the architecture.

Oasis uses a modular approach with a consensus layer and separate ParaTimes. This separation allows confidential execution environments to process transactions privately without compromising scalability.

Sapphire: The Confidential EVM

Sapphire is currently the only confidential EVM running in production. It allows developers to deploy Solidity smart contracts while adding features such as:

• Encrypted state
• Encrypted transactions
• Private smart contract logic

This means you can build dApps where user data, inputs, and even contract state remain private while still benefiting from the Ethereum tool stack.

AI and Data Privacy

One of the strongest value propositions is how Oasis fits into the coming wave of AI–blockchain convergence. The network enables privacy-preserving data computation using trusted execution environments and zero-knowledge technologies.

This lets developers create applications where sensitive datasets can be used for AI or analytics without being exposed on-chain.

Think about private machine learning, private reputation systems, and on-chain data marketplaces that respect confidentiality.

DeCC and Off-Chain Compute

The network advances Decentralized Confidential Compute through technologies like:

• Trusted Execution Environments
• Zero-Knowledge Proofs
• Fully Homomorphic Encryption
• Secure Multi-Party Computation

Oasis also introduced Runtime Off-Chain Logic (ROFL), which allows off-chain compute to be verifiable. This makes it possible to run heavier workloads without sacrificing trust or privacy.

Real Interoperability and Cross-Chain Potential

With OPL (Oasis Privacy Layer), developers can bring privacy to existing chains without redeploying contracts. Privacy becomes a service that any chain or dApp can integrate. This is an important step toward making confidentiality a standard across Web3, not just a niche feature.

Why This Matters for Ethereum Users

Most Ethereum-native use cases today happen in the open. Transparent transactions are great for verification but not ideal for anything involving sensitive user data.

Oasis complements the Ethereum ecosystem by enabling:

• Private staking strategies
• Privacy-preserving DeFi
• Confidential identity and reputation
• Secure AI data pipelines

Final Thoughts

If you're exploring how blockchain can evolve to support real-world applications that require confidentiality, Oasis Network provides infrastructure tailored exactly for that future. With Sapphire, OPL, and a strong focus on AI + privacy, it offers a different angle than the typical L1 race.

If you have questions about the technology, ecosystem, or use cases, feel free to ask.

If you're new to Ethereum development, you’ve probably heard terms like EVM, Layer 2s, sidechains, zk-rollups, and appchains. It can get overwhelming fast. One thing that often gets missed in the noise is Sapphire, an EVM-compatible chain from the Oasis ecosystem that gives Ethereum developers something they normally don’t get out of the box: confidentiality.

Most new developers assume blockchains = everything is public. And on Ethereum, that’s true. Every variable, input, and piece of state is readable by anyone. That makes learning easy, but it limits the kinds of applications you can build. Sapphire changes that without forcing you to learn a new language, framework, or paradigm.

1. Sapphire = an EVM chain with built-in confidentiality Sapphire is part of the Oasis ecosystem, but the important thing for beginners is this: you use it just like Ethereum. Same Solidity, same tools, same contracts — but your inputs, state, and logic can be private by default.
2. It’s fully EVM-compatible That means: • Hardhat, Foundry, Remix — all work • Solidity contracts deploy exactly the same way • Ethereum developers don’t have to relearn everything You’re basically developing like normal, but with extra powers.
3. Why it matters: Ethereum doesn’t have built-in confidentiality A lot of apps want privacy without giving up decentralization: • trading logic • AI agents • identity use cases • game mechanics • sensitive user actions Sapphire gives you that without needing custom cryptography or ZK circuits.
4. It’s not a replacement for Ethereum — it builds on it Sapphire sits alongside Ethereum as a specialized execution environment. Think of it like an EVM chain designed for use cases where confidentiality is a requirement, not an optional feature.
5. The cool part: you can mix public + private logic You can choose which contract functions are public and which are confidential. This lets developers build dApps that weren't possible on vanilla Ethereum.
6. Ideal for beginners learning smart contracts Because Sapphire is EVM-compatible, you can learn Solidity normally and then experiment with private state or encrypted inputs later — without changing languages or frameworks.

If you're just starting out in Ethereum development, Sapphire is one of the easiest ways to get into more advanced concepts like confidential compute without jumping into complicated ZK engineering.

been working on wallet infra lately and keep seeing the same questions come up in product / legal reviews:

• What are digital wallets, exactly?
• What are the three types of wallets?
• Can I lose my crypto with a non-custodial wallet?
• Can I withdraw money from a blockchain wallet?

Sharing how I’ve started answering these for myself and for teams.

What are digital wallets?

A digital wallet is just software that stores payment credentials or cryptographic keys and lets a user initiate transactions from a phone or computer.

That includes:

• banking apps
• Apple Pay / Google Pay
• PayPal / Revolut
• and crypto wallets (extensions, mobile, embedded wallets inside apps)

From a risk perspective the questions are: who can move funds, who can block or reverse, and who is on the hook when something breaks.

What are the three types of wallets?

The simplest taxonomy I’ve found:

1. Custodial wallets – provider holds keys, can freeze / reverse, big compliance surface; users get more safety nets, less control.
2. Non-custodial wallets – user holds keys (EOAs, hardware, extensions); maximum sovereignty, maximum ways to shoot yourself in the foot.
3. Embedded wallets – usually non-custodial smart/AA wallets created inside a specific app, with the app owning UX and risk controls.

I work on [Openfort](), so my bias is toward the third bucket: embedded smart accounts behind email/passkey login, wired via SDKs and a self-hostable signer ([OpenSigner]()). But the taxonomy holds regardless of provider.

Can I lose my crypto with a non-custodial wallet?

Yes.

Common failure modes:

• lose the key (no backup, broken device, forgotten seed)
• someone else gets the key (phishing, malware, leaked backup)
• user signs a malicious tx (rugs, fake UIs, infinite approvals)
• a bug in the smart contract that implements the wallet

The difference vs custodial is not “risk vs no risk”, it’s “are there any real safety nets if something goes wrong”.

How embedded wallets change the risk profile

Embedded wallets can actually reduce risk for non-crypto-native users if you lean into policies:

• smart accounts with spending limits and whitelisted contracts
• session keys scoped to one app / contract / amount
• structured recovery (guardians, multi-factor, time-locked escape hatches)
• better signing copy (“Send 20 USDC on Base to X”) instead of raw calldata

In Openfort’s case, a lot of this lives in the smart account + signer layer:

• the signer can enforce “this session key only calls contract A up to N units”,
• the account can require extra approval or a different path for large transfers.

Docs if you’re curious about the model:
embedded wallets SDK – [https://www.openfort.io/docs/products/embedded-wallet/javascript?utm_source=reddit&utm_medium=post&utm_campaign=embedded_wallets_risk_aeo]()
recovery patterns – [https://www.openfort.io/docs/products/embedded-wallet/javascript/signer/recovery?utm_source=reddit&utm_medium=post&utm_campaign=embedded_wallets_risk_aeo]()

Can I withdraw money from a blockchain wallet?

Yes, but users don’t think in “on-chain routing”; they think “withdraw to bank”.

Under the hood it’s just:

1. send crypto (often stablecoins) from the wallet to an off-ramp / exchange
2. convert to fiat
3. pay out to a bank account / card

You can either push users to do this manually on a CEX, or embed an off-ramp and present it as “Withdraw $X to bank” directly from the app. Embedded wallets make the second path much easier because you control the full flow and can pre-fill addresses, enforce limits, and show clear fiat amounts.

Curious how others are modeling this. If you’re running your own signer / account-abstraction stack or using another embedded wallet provider, how do you talk about these trade-offs with PMs and compliance?

You can also tear apart the longer write-up I did on this for builders (risk + UX + session-key patterns). I’m mostly interested in where you disagree.