WallCard

WallCard is a non-custodial crypto wallet but in a card form, not a browser extension. You link a virtual card (number, CVV, and PIN) to EVM, Solana, and Sui accounts behind the scenes. When a site or app needs a signature or transaction, you approve with the same habits you already trust: card details, PIN, and a one-time code (or a push approval on the mobile app), instead of MetaMask popups or seed phrases on every action.

For developers, WallCard exposes a familiar wallet interface (Session Connect for dApps, SDK examples, WalletConnect-style flows) so users can sign messages, send transactions, and use advanced features like sending USDC while paying from USDT via integrated swap and settlement, without installing an extension. Security is built around sealed PIN transport, short-lived unlock tokens, OTP policy, and World ID selfie approval on mobile.

WallCard is for anyone who wants Web3 access without another browser plugin: consumers who think in cards and PINs, and products that need embedded signing with clearer UX than raw wallet extensions.

Built for agents

AI agents should propose on-chain work, not hold your private keys. WallCard gives agents a card identity and a controlled signing path: routine agent requests can complete with email OTP while keys stay in WallCard custody, not in prompts, logs, or agent memory. Larger or sensitive moves can escalate to push approval and slide-to-approve on your phone. You can enable an agent card preference so automation is explicit, and every request shows up in activity so you can audit what ran, from where, and whether it was approved.

Granular signing controls

You decide what your wallet is allowed to do. WallCard exposes per-method toggles for signing vs transaction categories: personal messages, EIP-712 typed data, raw hash sign (higher risk), SUI message and transaction flows, EVM send and sign transaction, account abstraction user operations, and EIP-5792 batch calls (wallet_sendCalls). You can turn individual methods on or off, disable all transactions while keeping read-only signing, and configure OTP policy (including thresholds) so high-impact actions always need extra verification. dApps that call a disabled method are blocked at policy, not silently signed.

Your account number is your public identity

Every user gets a 16-digit WallCard account number with checksum validation. That number is what you share to receive funds or identify yourself in the app, similar to a bank account number, instead of copying long hex or base58 addresses. Behind the scenes it resolves to your linked EVM, Solana, and Sui addresses, so sends and lookups work from one memorable identifier while on-chain settlement still uses the correct chain-specific address.

World ID identity and Selfie Check

World integration adds human verification without storing raw biometrics on WallCard. Identity Check can gate onboarding (for example minimum age) using World proofs verified server-side with nullifier tracking to prevent replay. Selfie Check replace typing your sealed PIN on mobile push approval when you enable it in settings: you slide to verify with a World selfie proof, then the approval completes. Enrollment and verification flows run through World Kit; only proof artifacts and nullifiers are persisted, aligned with a privacy-first approval model for high-trust actions on device.

Uniswap universal settlement

WallCard includes an auto-settlement engine powered by the Uniswap Trading API for supported EVM chains. You can send one token while paying with another (for example receive USDC but spend USDT): the server quotes an exact-output swap, assembles swap plus transfer into an atomic wallet_sendCalls batch, and handles Permit2 signing as part of your single approval at confirm. Quotes refresh at confirm so push approval delays do not stale the route. The same settlement hint works from the mobile Send screen, SDK requestAutoSettle, and onetime-connect flows for dApps that want conversion at signing time without a separate DEX UI.

Built for Ethereum(EVM) and SUI Blockchain Wallcard on noderails card network is building what VISA or Mastercard is for fiat but for crypto rails.

WallCard is a pnpm + Turborepo TypeScript monorepo. A public Express API (Postgres, Redis, background workers for OTP email) handles accounts, virtual cards, signing policy, chain and token settings, push approval, and an audit trail of every signing request. Wallet keys are never assembled on that API. A separate signer service runs in a locked-down environment and is the only place reconstruction and signing happen. Frontends are Next.js (site and operator tools), Expo (iOS, Android, and wallet web for SDK popups/iframes), plus @wallcard/sdk-core and @wallcard/sdk-react for partners.

Non-custodial 2-of-3 key sharing

We split each wallet into three shards using threshold secret sharing (2 of 3 must combine to sign):

• User / device shard tied to what only you control: your card number, CVV, and PIN, delivered and verified through the app or wallet web (PIN is sealed client-side before it crosses the network).
• WallCard shard held in our secure infrastructure (encrypted at rest, bound to your account and signing policy).
• Distributed shard held by an independent distributed signing network (we use a hosted wallet partner for EVM and Sui execution). No single shard is enough to spend. WallCard cannot move funds with only our shard. The distributed network cannot act without WallCard policy and your proof. You cannot sign without passing card verification and PIN in an authorized session. When you approve a message or transaction, the signer service pulls together two of the three shards inside an isolated process: your live card proof unlocks the user side, our shard and the distributed shard complete the threshold, the signature is produced, and combined material is discarded immediately. dApps and agents receive signatures, not exported keys.

Flows we built

• Session Connect: card + CVV + PIN opens a short-lived session so sites can read your linked EVM and Sui addresses without holding keys.
• Onetime Connect / SDK: each action creates a signing request, then email OTP, push slide-to-approve, or card confirm; confirm always goes through the signer boundary above.
• 16-digit account number: your public payment ID; it resolves to on-chain addresses for sends and lookups.
• Agents: same approval rails; automation never receives shard material. Settlement and identity engineering

Uniswap Trading API drives pay-with-one-token, send-another: quote, swap, and transfer are merged into one batch transaction (wallet_sendCalls) so one user approval covers conversion plus send; quotes refresh at confirm when approval takes time. World ID runs on our API (mobile opens World App via QR/deep link, polls verified proofs) for identity at onboarding and Selfie Check on high-trust mobile approvals; we store verification state, not raw biometrics.