The problem Orbit solves

When you send someone crypto, they can look up the transaction on Etherscan and see your entire wallet balance , every token, every transaction, every DeFi you interacted with on-chain, your complete financial history exposed from a simple payment. Onchain TX and DeFi offers no privacy....

Orbit fixes this using zero-knowledge proofs. When you send USDC through Orbit, the recipient gets their money but can't see where it came from, can't look up your balance, can't trace your history. The payment appears from an unlinkable address, exactly how private payments should work. For 100% Anonymity, we also included gas relayers that deducts the original premium and pays gas for users as a form of gas abstraction

Demo Transaction using Orbit's logic:
[Left: sender, Right: recipient]

Here's how it works:
Tokens get "shielded" into RAILGUN's private pool. We generate a ZK proof that mathematically proves you can spend those tokens without revealing which ones or who you are. Then the recipient gets paid through an "unshield" transaction with zero on-chain connection to the original. The cryptography makes linking them impossible.

Our Idea:

Our Solution:

zkWormhole page:

Bonus batch payments: pay multiple recipients in different stablecoins (supports locality) with one signature. Each person receives from an unlinkable source. Perfect for payroll where employees shouldn't see each other's salaries.

Challenges we ran into

POI timing confusion
After shielding, there's a 60-90 second "Proof of Innocence" verification before funds become spendable. Users saw tokens but couldn't spend them. We split balance into "spendable" vs "pending POI" with a countdown timer.

Encryption key mismatches
Client-side and server-side key derivation produced different results due to encoding differences, causing "wallet not found" errors. We cache the canonical key server-side on wallet creation.

Gas abstraction
We wanted zero-gas UX but Ethereum needs ETH for every transaction. We use EIP-2612 permits (gasless signatures) plus a relayer that executes and pays for all on-chain operations.

Multi-token batches
RAILGUN only supports one token per ZK proof, but users want to pay Alice in USDC and Bob in DAI together. We group by token, shield each separately, wait for POI in parallel, then generate proofs sequentially with balance sync waits between each.

Real-time updates
Transfers take 2-3 minutes and Next.js doesn't support SSE natively. We built a custom ReadableStream implementation that pushes progress events to the client.