Cash.io

Inspiration

The fragmented nature of the blockchain ecosystem has created significant friction for users. Moving assets between networks like Ethereum, Solana, and Bitcoin is often slow, expensive, and leaves a visible trail of financial data. We were inspired by the need for a unified, privacy-first financial layer—a system where users can transact seamlessly across any chain without sacrificing their anonymity or paying exorbitant gas fees. Cash.io was born out of the vision to combine the privacy of ZK-SNARKs, the UX of Account Abstraction, and the interoperability of cross-chain messaging into a single, cohesive hub.

What it does

Cash.io is a multi-chain, zero-knowledge privacy dApp that allows users to shield, transfer, and unshield assets across different blockchains.

• Privacy-Preserving Transactions: Using a shielded pool model (notes and nullifiers), users can deposit funds on one chain and privately transfer them to others without revealing amounts or receiver addresses.
• Cross-Chain Bridging: We support bridging between EVM chains (like Ethereum/Sepolia), Solana, and Bitcoin (via Rootstock).
• Zero-Fee UX: By integrating ERC-4337 Account Abstraction and Paymasters, users experience gasless transactions.
• AI-Powered Agents: We've integrated LangGraph.js agents to parse natural language intents ("Send 0.5 ETH to Alice privately") and automatically orchestrate the ZK proof generation and cross-chain bridging process.

How we built it

We architected Cash.io using a Hub-and-Spoke model:

• The Hub: An Avalanche Subnet-EVM serves as the central aggregation layer. It houses our core ShieldedPool contract, the CommitmentTree, and a custom ZK Verifier precompile for ultra-fast Groth16 proof verification.
• The Spokes: Bridge contracts deployed on various chains (Ethereum, Solana, Rootstock) that lock/unlock funds and communicate with the Hub.
• Relayer Network: A TypeScript-based relayer watches for cross-chain deposit events, generates necessary proofs, and submits them to the Hub's TransactionRegistry.
• Frontend & SDK: Built with React, Vite, and Viem. The frontend manages local ZK note generation, interacts with smart contracts, and securely encrypts recovery keys using decentralized IPFS (Pinata) storage.
• ZK Circuits: We used Circom and SnarkJS to build circuits for private transfers, deposits, and withdrawals, ensuring value conservation and ownership verification without revealing underlying data.

Challenges we ran into

Building a highly complex, multi-chain architecture came with immense challenges:

• Cross-Chain State Synchronization: We struggled with synchronizing state between the Spoke chains and the Hub. Specifically, handling the liquidity for withdrawals required careful orchestrating of our Relayer logic so that the ShieldedPool could properly payout unshielded funds without reverting.
• Smart Contract & Frontend Mismatches: Keeping our local Hardhat deployments, frontend ABI configurations, and Relayer environments perfectly aligned was a massive hurdle. We encountered multiple instances where raw byte data was mistakenly sent instead of proper ABI-encoded function calls (e.g., during privateTransfer), which required deep debugging with Viem and Ethers.js.
• Non-EVM Integrations: Implementing bridges for non-EVM chains like NEAR and Solana required dealing with different serialization formats (like Borsh incompatibility issues we had to patch in NEAR).

Accomplishments that we're proud of

• End-to-End Privacy Flow: Successfully building a fully functional ZK-SNARK circuit that interacts cleanly with our smart contracts. Seeing a shielded transfer execute with a zero-knowledge proof verifying perfectly on-chain is incredibly rewarding.
• AI Agent Integration: Bridging the gap between Web3 complexity and Web2 UX. Our LangGraph.js agents successfully interpret user intents and handle the heavy lifting of proof coordination in the background.
• Resolving the Hub-and-Spoke Liquidity: We successfully debugged and fixed critical architectural issues in our bridge logic, ensuring that cross-chain deposits hit the correct bridge contracts instead of mistakenly targeting the Hub's pool directly.

What we learned

• Viem vs Ethers: We gained a deep understanding of Viem's encodeFunctionData and how strictly it differs from raw byte manipulation, teaching us valuable lessons in frontend-to-contract communication.
• Relayer Architecture: We learned that a robust relayer needs exceptional error handling and state tracking to prevent double-spending and ensure that cross-chain proofs are reliably submitted to the destination chain.
• Local Testing Environments: Managing a local multi-chain environment (Hardhat node mimicking the Avalanche Subnet, bridging to Sepolia) taught us the importance of rigorous environment variable management and deterministic deployments.

What's next for Cash.io

• Mainnet Deployments: Transitioning our testnet bridge contracts to Ethereum Mainnet, Solana Mainnet, and Avalanche C-Chain.
• Decentralized Relayer Network: Transitioning from our current centralized relayer service to a decentralized network of provers to ensure trustlessness.
• Optimized ZK Circuits: Implementing recursive SNARKs to allow for massive batch processing of private transfers, drastically lowering the gas footprint on the Hub chain.
• Mobile Application: Packaging our Web SDK into a React Native mobile application for true on-the-go private payments.

Built With

• ether.js
• langraph
• react.js
• wagmi
• zk-snarks