"If your 'non-custodial' wallet broadcasts every signing request and approval pattern on-chain, attackers don't need your keys—they can just watch when and how you move money."
We've built an entire industry around the promise of "not your keys, not your crypto." Self-custody is sacred in DeFi—you control your private keys, you control your funds, nobody can freeze your account or steal from you without access to those keys. It's a beautiful idea. But there's a massive problem we barely talk about: even if your keys stay private, everything you do with them becomes public.
Every time you sign a transaction, approve a contract, or unlock your wallet, that action gets broadcast, timestamped, and permanently recorded on-chain. Attackers, competitors, and sophisticated analysts can watch these patterns and extract enormous value—sometimes without ever touching your keys.
Let's break down why this happens, and how confidential computing finally gives us real key privacy.
The Hidden Exposure: Keys vs. Usage Patterns
When people talk about key security, they think about:
- Hardware wallets protecting private keys
- Seed phrases locked in safes
- Multi-signature schemes requiring multiple approvals
But they're missing something critical: the pattern of how you use those keys leaks almost as much as the keys themselves.
Every signature request reveals:
- When you move money - attackers time their moves around yours
- How much you typically move - they infer your risk tolerance and capital
- Which addresses you interact with - they map your financial relationships
- Your approval patterns - they predict your next moves
- Your security practices - they learn when you check balances, update permissions, etc.
Analogy: It's like having a secret door with an invisible lock, but you always visit it at the same time, stay for the same duration, and leave the same way. An observer might not pick the lock, but they know your entire schedule and can plan around you perfectly.
Why Hardware Wallets Aren't Enough
Hardware wallets are excellent—they keep keys offline and require physical confirmation for signatures. But:
- Transaction details still go on-chain - the hardware wallet proves you signed something, but what?
- Approval requests are visible - when you approve a contract, everyone sees it
- Timing metadata leaks - when you sign and how long you think reveals behavior
- Interaction patterns become trackable - sophisticated watchers can correlate your actions across protocols
A determined attacker or competitor watching your signing behavior can:
- Front-run your moves by spotting approval patterns
- Sandwich your trades by predicting when you'll execute
- Exploit liquidation windows by monitoring your position management
- Target you personally by correlating your wallet with known identities
The Real Problem: Wallets That Hide Keys But Broadcast Everything Else
Current non-custodial wallets solve for key custody but not usage privacy:
- Keys stay in hardware ✓
- But transaction intent is visible ✗
- Multi-sig provides security ✓
- But every approval is public ✗
- Self-custody is preserved ✓
- But behavioral patterns are exposed ✗
We've created a system where you control your keys but can't control what people learn by watching how you use them.
The Solution: Confidential Key Management with User Control
What if we could:
- Keep keys truly private - not just in hardware, but in secure hardware-backed enclaves
- Make signing operations confidential - signing happens without broadcasting intent
- Preserve user control - you still control when and how your keys are used
- Enable complex logic privately - multi-sig, timelock, spending limits all work without exposure
This is possible with Trusted Execution Environments (TEEs) combined with account abstraction.
Using Oasis Network's ROFL framework and Sapphire's confidential smart contracts:
How It Works
- Private key derivation happens inside TEE-secured environments
- Signing requests are processed confidentially without broadcasting what's being signed
- Approval logic (multi-sig rules, spending limits) executes privately
- Only results (the signature or approval) go on-chain, not the details
- User maintains control - they decide when keys are used through encrypted commands
What This Enables
- Invisible transaction building - you can approve and execute without leaking your moves
- Private spending rules - multi-sig and timelock logic works without public visibility
- Confidential position management - you can adjust DeFi positions without MEV bots watching
- Hidden security practices - your wallet update and recovery procedures stay truly private
- Key rotation without exposure - change keys without broadcasting the change
Real Implementation: Confidential Wallet Infrastructure
Encrypted Signing Services
- Keys stored in TEE-backed vaults that you control
- Signing happens inside the enclave - request goes in encrypted, signature comes out verified
- User confirmation still required, but done privately through encrypted channels
- Audit logs show when keys were used, but not what they signed
Account Abstraction with Private Key Management
- Email or biometric authentication for seamless UX
- Encrypted session keys that don't reveal your usage patterns
- Private spending policies that execute without visibility
- Confidential recovery if your device is lost
Multi-Sig with Privacy
- Private threshold encryption - every co-signer's approval is confidential
- Encrypted ballot systems for governance voting on key rotation
- Hidden quorum requirements - attackers don't know how many signatures are needed
- Confidential dispute resolution - disagreements about key access happen privately
Why This Matters in 2025
- DeFi is now sophisticated enough that behavioral patterns matter as much as keys
- MEV extraction has evolved - bots no longer just front-run, they predict and position
- Enterprise adoption is blocked - large players can't accept wallets where every move is broadcast
- Personal security is at risk - wealthy individuals can't safely hold crypto if their activity is fully visible
Getting Started as a Developer
- Understand the exposure: Map every way a wallet reveals information beyond the transaction itself
- Explore ROFL for confidential signing: https://docs.oasis.io/build/rofl/
- Build with Sapphire's confidential contracts: Create encrypted key management logic https://oasis.net/sapphire
- Study account abstraction patterns: Learn how to layer privacy into wallet design
- Join the Oasis privacy community: Discuss wallet security with other builders https://forum.oasis.io/
TL;DR
Non-custodial wallets gave us key ownership, which was huge. But they left us exposed in a different way—through usage patterns that broadcast our intentions to the world. Real privacy in DeFi means keeping keys secure and keeping their usage confidential. With confidential computing, you can finally have self-custody that actually feels private.
The future of DeFi wallets isn't just about protecting keys—it's about protecting the entire story those keys tell. And that story is worth more than the keys themselves.
Top comments (2)
This nails a blind spot most wallet designs ignore: keys may be private, but behavior isn’t.
Once MEV and on-chain analytics get sophisticated, signing and approval patterns leak almost as much as the keys themselves. Hardware wallets and multisig help, but they only solve custody, not usage privacy.
The Oasis approach (ROFL + Sapphire) is interesting because it shifts the problem from “where are keys stored?” to how signing and policy logic executes. Private signing and confidential approval logic feels like the missing layer between self-custody and real safety.
Account abstraction alone won’t fix this, without confidentiality, it just creates more observable signals.
Great breakdown key management is absolutely one of DeFi’s toughest unsolved problems, and the article does a good job showing why existing solutions haven’t fully closed the gap. It’s a reminder that confidential key handling and decentralized key management aren’t just convenience features they’re foundational for long-term security, especially as protocols and agents execute on behalf of users. Solutions that integrate verifiable, private execution environments can really raise the bar here by keeping critical secrets secure and accountable. If you want a future where DeFi scales without compromise, this is exactly the kind of problem we need to solve.