Chainless

Chainless is a privacy-first, chain-abstracted cryptocurrency wallet that enables users to manage digital assets across 13+ blockchain networks with complete transaction privacy through stealth addresses, all while providing a unified balance view and intelligent cross-chain transaction routing.

The Core Problem:

Traditional cryptocurrency wallets suffer from three critical issues:

Privacy Vulnerability: Every transaction is permanently linked to your wallet address on public blockchains. Anyone can view your complete transaction history, balances, and trading patterns by simply searching your address on a block explorer. This creates serious privacy concerns for individuals and businesses.

Multi-Chain Complexity: Users must manually switch between different blockchain networks, manage separate balances on each chain, bridge assets between networks through complex processes, and maintain multiple gas tokens. This creates cognitive overload and frequent transaction failures.

Poor User Experience: The current Web3 UX requires deep technical knowledge about gas fees, network selection, bridge protocols, and blockchain mechanics - creating massive barriers to mainstream adoption.

The Chainless Solution:

Chainless solves these problems through four revolutionary layers:

1. Privacy Layer (Fluid Key SDK Integration)

Stealth Address Technology: When you want to receive funds privately, Chainless generates a one-time "stealth address" using the Fluid Key SDK This stealth address is derived deterministically from your main wallet using ECDH (Elliptic Curve Diffie-Hellman) cryptography combined with BIP32 key derivation The sender sends funds to this temporary stealth address instead of your main wallet On-chain, observers only see funds going to an unconnected address (0x9ABC...) with no link to your real wallet (0x1234...) You can later "claim" these funds privately by transferring them from the stealth address to your main wallet The blockchain only shows a transfer from 0x9ABC to 0x1234, but cannot connect this to the original sender.

Key Privacy Features:

Deterministic key derivation ensures you never lose access to funds All stealth addresses are recoverable from your main wallet Private keys are encrypted with AES-256 and stored locally (never on servers) Dust filtering automatically hides gas remnants (under 0.0001 ETH) Privacy indicators in transaction history show which transactions used stealth addresses Works across all 13+ supported blockchain networks

1. Chain Abstraction Layer (Avail Nexus SDK Integration)

Unified Balance Aggregation: Instead of seeing separate balances on Ethereum, Arbitrum, Base, Optimism, etc., Chainless shows ONE total balance Behind the scenes, Avail Nexus SDK queries all 13+ chains in parallel and aggregates your assets Example: You have 10 PYUSD on Sepolia, 30 PYUSD on Arbitrum, 15 PYUSD on Base → Chainless displays "55 PYUSD Total" The UI hides blockchain complexity completely - users never need to know or care which chain their funds are on

Intent-Based Execution: Traditional wallets require 7+ manual steps to send funds across chains (switch network, bridge, wait, switch again, send) Chainless uses "intent-based" architecture where you simply specify: "Send 50 PYUSD to Bob" The Nexus SDK automatically:

Identifies which chains hold your PYUSD balance Creates an optimal execution plan Withdraws from multiple source chains simultaneously Bridges funds to the destination chain Delivers the combined amount to the recipient All in ONE user action Cross-Chain Transfer Example:

1. Intelligence Layer (Envio HyperSync Integration)

Recipient Chain Analysis: Before sending funds, Chainless analyzes the recipient's transaction history across ALL chains using Envio HyperSync HyperSync is a high-performance blockchain indexer that scans the last 500 blocks on each chain simultaneously It counts how many transactions the recipient has made on each network Chainless automatically selects the chain where the recipient is most active This means Bob receives funds on the blockchain he actually uses, reducing his gas costs and friction . Real-Time Blockchain Data: Envio provides sub-second blockchain data updates Multi-chain indexing across all 13+ supported networks GraphQL API for flexible transaction queries Historical analysis for optimal routing decisions

1. Stablecoin Integration (PYUSD - PayPal USD)

Why PYUSD: Regulatory clarity: Issued by PayPal with full compliance Cross-chain availability: Deployed on Ethereum, Arbitrum, Base, Optimism, and more Lower slippage: High liquidity across DeFi protocols Preferred stable asset for cross-chain transfers Yield opportunities: Compatible with Aave, Compound, and other lending protocols

PYUSD Throughout Chainless: Primary stablecoin displayed in UI Optimized bridging routes for PYUSD transfers Privacy-enabled PYUSD receives via stealth addresses Yield strategies deployed with PYUSD collateral Lower gas costs due to optimized contract interactions Technical Architecture

Technology Stack: Frontend: React 18.3 + TypeScript 5.6 + Vite 6.0 + Tailwind CSS v4 Blockchain: Wagmi 2.13 + Viem 2.21 + RainbowKit 2.2 + ethers.js 6.13 Privacy: Fluid Key SDK 1.1.0 (stealth addresses, ECDH derivation) Chain Abstraction: Avail Nexus SDK 0.0.1 (unified balances, intent engine) Analytics: Envio HyperSync (blockchain indexing, recipient analysis) Supported Networks (13 Testnets):

Ethereum Sepolia Arbitrum Sepolia Base Sepolia Optimism Sepolia Polygon Amoy Avalanche Fuji BSC Testnet Scroll Sepolia Linea Testnet Mantle Testnet Filecoin Calibration Zora Testnet Celo Alfajores

Advanced Features:

1. Privacy-Preserving Yield Strategies: Deploy assets to DeFi protocols (Aave, Compound) through stealth addresses Earn yield across multiple chains simultaneously Withdraw profits to new stealth addresses or main wallet Complete privacy: Protocol interactions can't be linked to your main wallet

2. Transaction History Tracking: All transactions stored locally with privacy indicators Lock icon overlays on private (stealth address) transactions Click any transaction to view on block explorer Types: Send, Receive, Yield Deployment, Claim, Swap Event-driven updates: Real-time UI synchronization

3. Dust Filtering: Automatically hides balances under 0.0001 ETH Prevents UI clutter from gas remnants Only shows claimable funds worth transferring

4. Custom Notification System: Professional slide-in notifications (no browser alerts) CSS animations for smooth UX Success/error states with contextual messages Non-intrusive design that doesn't block workflow

Real-World Use Cases:

1. Private Business Payments: Company receives client payment via stealth address Client can't track company's other business transactions Company claims funds privately to main treasury wallet Maintains financial privacy while accepting crypto payments

2. Multi-Chain Asset Management: User has funds scattered across Ethereum, Arbitrum, Base, Optimism Sees unified balance: "100 PYUSD Total" instead of managing 4 wallets Sends 80 PYUSD with one click (automatically pulls from all chains) Never needs to bridge or switch networks manually

3. Smart Cross-Chain Transfers: Alice wants to send Bob 50 USDC Chainless analyzes: Bob mainly uses Arbitrum Automatically routes to Arbitrum (Bob's preferred chain) Bob receives funds on his main chain without bridging

4. Private DeFi Participation: Deploy 1000 PYUSD to Aave via stealth address Earn 5.2% APY on Sepolia Simultaneously deploy to Compound on Arbitrum Withdraw profits to new stealth addresses On-chain: No link between deposits and your main wallet Security Model

Privacy Security: Stealth addresses generated client-side only (never touch servers) Private keys encrypted with AES-256 before localStorage Deterministic derivation allows wallet recovery Zero-knowledge privacy without trusted third parties

Transaction Security: All transactions require MetaMask signature approval Client-side validation before execution Comprehensive error handling and gas estimation 20% gas buffer to prevent out-of-gas failures

Smart Contract Safety: Only integrates with audited DeFi protocols No custom smart contract deployment required Standard ERC-20 token interactions Testnet validation before any mainnet deployment

Why Chainless Matters:

For Users: Financial privacy restored in transparent blockchain world Simple UX: No network switching, no bridging, no confusion Intelligent routing saves gas and reduces friction One wallet for all chains

For Blockchain Adoption: Removes technical barriers for mainstream users Demonstrates that Web3 can be as easy as Web2 Privacy-first approach addresses regulatory concerns Chain abstraction enables seamless multi-chain future

For Partner Technologies: Avail Network: Showcases Nexus SDK's chain abstraction power Envio: Demonstrates HyperSync's real-time indexing capabilities PYUSD: Highlights stablecoin utility in DeFi ecosystem Fluid Key: Proves stealth addresses enable practical privacy

Development Status: Current State: Fully functional testnet deployment

✅ Privacy mode with stealth addresses working ✅ Unified balance aggregation across 13 chains ✅ Cross-chain transfers with intent execution ✅ Recipient chain analysis via Envio ✅ Yield strategies with privacy wrapping ✅ Transaction history with privacy indicators ✅ PYUSD integration across all features

Next Steps: Security audit for mainnet deployment Mobile application (iOS/Android) Enhanced yield strategies with auto-compounding Cross-chain DEX aggregation Private NFT transfers Zero-knowledge proof integration Project Vision

Short Term: Demonstrate that blockchain wallets can provide both privacy and simplicity without compromising user control or security.

Long Term: Become the standard interface for multi-chain asset management where users never need to understand gas, networks, or bridges - just like they don't need to understand TCP/IP to use the internet.

Ultimate Goal: Make blockchain invisible. Users should interact with value, not networks. Privacy should be default, not optional. Complexity should be abstracted, not exposed.

Chainless represents the future of cryptocurrency wallets: private, simple, and truly multi-chain.

Architecture Overview Chainless is built as a modern React single-page application that orchestrates three core partner technologies (Avail Nexus, Envio HyperSync, and Fluid Key SDK) into a unified privacy-first wallet experience. The architecture follows a layered approach where each partner technology handles a specific domain, with our custom integration layer binding them together seamlessly.

Core Technology Stack & Integration Frontend Foundation React 18.3 + TypeScript 5.6: Chosen for type safety and developer experience. Every component is fully typed, preventing runtime errors. Vite 6.0: Lightning-fast dev server with HMR (Hot Module Replacement). Build times under 10 seconds even with 40+ components. Tailwind CSS v4: Utility-first styling with custom color variables for privacy mode theming (--primary: #5D3FD3 for privacy purple). shadcn/ui: Radix UI primitives for accessible components (Dialog, Card, Badge). All components in ui are customized for our dark theme. Blockchain Integration Layer Wagmi 2.13 + Viem 2.21: Modern React hooks for Ethereum interactions. We configured 13 custom chains in wagmi.ts with proper RPC endpoints and block explorers. RainbowKit 2.2: Wallet connection UI that supports MetaMask, WalletConnect, Coinbase Wallet. Custom theme matching our purple privacy mode. ethers.js 6.13: Used specifically for stealth address balance checking and private key wallet creation (Viem doesn't support wallet creation from private keys as elegantly). Partner Technology Integration (The Interesting Stuff)

1. Avail Nexus SDK - Chain Abstraction Engine Implementation (nexus.ts):

How We Use It:

Unified Balance Query (Dashboard.tsx:125): Called every 30 seconds to aggregate balances across all chains. Returns a structured object with per-chain breakdown that we hide from users but use for intent execution. Cross-Chain Transfers (SendTransaction.tsx:180): The magic happens here. We pass recipient, amount, and token. Nexus SDK handles all bridging internally using their intent engine. Liquidity Sourcing: Nexus provides testnet liquidity pools that make cross-chain transfers possible without manual bridging. The Hacky Part: Nexus SDK expects a Web3Provider but RainbowKit gives us a Viem client. We created a compatibility shim:

Why It's Beneficial: Without Nexus, we'd need to integrate 5+ different bridge protocols (Across, Hop, Stargate), manage liquidity ourselves, and handle bridge failures. Nexus abstracts this completely with their intent-based execution model.

1. Envio HyperSync - Blockchain Indexing & Analytics Implementation (envio.ts):

How We Use It:

Recipient Analysis Dialog (RecipientAnalysisDialog.tsx): Shows a visual breakdown of recipient activity across chains before sending. Auto-Routing: Automatically selects destination chain based on recipient's most active network. Transaction Discovery: Scans last 500 blocks per chain in parallel - takes ~2-3 seconds for all 13 chains. The Clever Part: HyperSync's GraphQL API is incredibly fast (sub-second responses), but querying 13 chains could still be slow. We use Promise.all() for parallel execution and cache results for 5 minutes using a simple Map:

Why It's Beneficial: Traditional approach would require running our own blockchain indexer nodes for 13 chains. That's infrastructure hell. Envio's HyperSync gives us production-grade indexing as an API with GraphQL flexibility.

1. Fluid Key SDK - Privacy Layer with Stealth Addresses Implementation (fluidKey.ts):

Claiming Mechanism (claimFunds.ts): This is where it gets really interesting. We need to transfer funds FROM a stealth address (using its private key) TO the user's main wallet:

The Hacky But Necessary Part: Fluid Key SDK generates keypairs, but doesn't handle claiming. We had to build the entire claiming mechanism ourselves using ethers.js Wallet class. The tricky part was gas estimation - if we estimate too low, transaction fails; too high, we leave dust behind. Solution: 20% buffer with fallback gas prices.

Balance Checking Without Indexers:

Why It's Beneficial: Building stealth addresses from scratch would require deep cryptography knowledge (ECDH, BIP32, Keccak256). Fluid Key SDK handles this with deterministic derivation, ensuring users never lose access to funds even if localStorage is cleared (can regenerate from main wallet).

Custom Integration Layers We Built

1. Transaction History System (transactionHistory.ts) Traditional wallets rely on blockchain indexers for transaction history. We built a local-first system using localStorage with event-driven updates:

Event-Driven UI Updates:

Why We Did This: Querying Envio for every transaction on every page load is wasteful. Local-first means instant loads, offline support, and we only query blockchain for balance checks (not history).

1. Custom Notification System We replaced browser alert() with a DOM-based notification system that doesn't block the UI:

CSS Animations (index.css):

1. Privacy Context for Global State Instead of prop drilling privacy mode through 10+ components, we use React Context:

Dynamic Theming: When privacy mode is enabled, the entire UI shifts to purple (#5D3FD3). We use CSS custom properties that update in real-time without page refresh.

Particularly Hacky Things Worth Mentioning

1. Dust Filtering for Claimable Funds After claiming from a stealth address, gas remnants (0.000002 ETH) remain. Users kept seeing "claimable" funds that weren't worth claiming. Solution:

Simple but effective. Anything under $0.30 (at current ETH prices) is hidden.

1. Wagmi + Viem + ethers.js Compatibility Layer Wagmi uses Viem, but Fluid Key SDK works better with ethers.js. We maintain both:

This dual-library approach adds bundle size (~100KB) but gives us the best of both worlds.

1. Chain Configuration Hell Configuring 13 testnet chains with proper RPCs, explorers, and icons:

Each chain needed testing to ensure RPC reliability. We spent 2 days just on chain configuration.

1. Gas Estimation Edge Cases Different chains have wildly different gas pricing:

Sepolia: ~10 gwei Arbitrum: ~0.1 gwei Polygon: ~50 gwei Our solution: Always fetch feeData from the provider and add 20% buffer:

Still fails sometimes on congested networks, but works 95% of the time.

Build & Deployment Pipeline Development:

Production Build:

Optimization Tricks:

Code splitting: Each route lazy-loaded Tree shaking: Unused shadcn components excluded Asset optimization: SVG icons inlined CSS purging: Tailwind removes unused classes Why This Stack Works React + TypeScript: Type safety prevents runtime errors. Every function, prop, and state is typed.

Vite: 10x faster than Webpack for dev server. HMR makes development smooth.

Avail Nexus: Single SDK replaced 5+ bridge integrations. Saves months of dev time.

Envio HyperSync: Production-grade indexing without running nodes. GraphQL flexibility is clutch.

Fluid Key SDK: Stealth addresses without PhD in cryptography. Deterministic recovery is genius.

ethers.js + Viem: Best of both worlds - modern React hooks (Viem) + powerful wallet creation (ethers).

localStorage: Instant loads, offline support, zero backend costs.

Challenges & Solutions Challenge 1: Nexus SDK initialization timing Solution: Singleton pattern with lazy initialization

Challenge 2: Stealth balance checking across 13 chains Solution: Parallel RPC queries with Promise.all()

Challenge 3: Gas estimation failures Solution: 20% buffer + fallback gas prices

Challenge 4: UI responsiveness during blockchain queries Solution: Optimistic UI updates + background refresh

Challenge 5: Privacy mode theme switching Solution: CSS custom properties + Context API

What We'd Do Differently GraphQL for Transaction History: Instead of localStorage, use Envio's indexer with custom queries Worker Threads: Move balance checking to Web Workers for better performance Smart Contract Relayer: Gas-free claiming using meta-transactions IPFS Metadata: Store transaction notes on IPFS for privacy Account Abstraction: Use ERC-4337 for better UX The Result A fully functional privacy-first multi-chain wallet that actually works. No smoke and mirrors - you can receive funds via stealth addresses, claim them privately, and send cross-chain transactions with automatic routing. All partner technologies integrated deeply, not just surface-level API calls.