pearpay

Pear Pay is a conversational payment protocol that lets you send money anywhere you communicate : iMessage, Telegram, WhatsApp, Discord, Slack, X, or even between AI agents. Instead of wallets, seed phrases, chains, bridges, swaps, and gas, you just express intent: "Send Molly $20," "Pay Alex back for dinner," or "Send Sarah 50 USDC privately."

Behind that single message, Pear Pay resolves the recipient (wallet address, phone, email, handle, or existing Pear Pay user), picks the optimal settlement rail, settles in USDC, and optionally shields the transfer so amounts and counterparties stay private.

Crucially, payments never fail because the recipient hasn't onboarded. If they have no wallet, Pear Pay escrows the USDC and delivers a claim link over SMS/WhatsApp via Twilio; the recipient taps it, an embedded wallet is created instantly through Dynamic, and the funds release — solving the cold-start problem that kills most crypto payment apps.

Pear Pay also extends to the agentic economy: AI agents get their own Dynamic server wallet (or Delegated Access MPC wallet after one Face ID grant) and can pay each other for APIs, compute, and data autonomously using HTTP 402 / x402 — the same infrastructure that powers human payments powering machine-to-machine commerce.

You can try it live at https://pearpay.app/: a clickable, screen-recordable Simulator reproduces the in-chat payment experience across six platforms (iMessage, Telegram, Discord, WhatsApp, Slack, X), and a "Try it" page does a real on-chain USDC transfer from your own wallet on Arc Testnet — a genuine, verifiable transaction on testnet.arcscan.app, not a mock. The homepage also runs a one-click Autonomous Private Agent timeline (Dynamic sign → Unlink shield → Circle Gateway x402 settle on Arc) that judges can screen-record end to end. A live Telegram bot webhook at /api/telegram parses payment intents and replies in-chat when configured.

Pear Pay is one unified TypeScript app: a Next.js (App Router) frontend + API that orchestrates every integration, with a thin native Swift iMessage extension where Apple requires it.

The brain is a dependency-free core in TypeScript so it behaves identically across every channel: an NLP parser turns "Send Molly $20 privately" into a structured PaymentIntent; a universal recipient resolver maps wallet address / phone / email / handle / existing-user to a delivery mode; a programmable escrow handles claimable payments; and a settlement orchestrator selects the rail per payment and serializes a JSON-safe result for the UI. Blockchain access is via viem/wagmi.

Two demo surfaces show this end to end: (1) a screen-recordable Simulator that reproduces the real in-chat UX across six platforms (iMessage, Telegram, Discord, WhatsApp, Slack, X) — pixel-faithful phone frame, on-screen iOS keyboard, and each platform's native confirmation pattern (Apple Pay sheet, Telegram inline buttons, Discord embeds, WhatsApp quick-replies, Slack Block Kit, X cards) — all sharing one tested component foundation; and (2) a live "Try it" page at /pay that does a REAL on-chain USDC transfer on Arc Testnet (chain 5042002): connect a browser wallet via wagmi (injected connector), switch to Arc if needed, and transfer() Circle's testnet USDC to any address with a verifiable Arcscan link — no sponsor accounts or funded server keys required.

Partner tech and how it helps:

• Dynamic — embedded wallets for instant onboarding-on-claim, Fireblocks Flow for cross-chain checkout that settles USDC on Arc, server/agent wallets for autonomous payments, and Delegated Access (Face ID once → backend signs autonomously via sealed MPC key shares).
• Arc (Circle) — Circle-native USDC settlement on Arc Testnet, PearPayEscrow.sol deployed on-chain (claim-secret release, expiry refund, sender cancel, dispute/arbiter), real @circle-fin/x402-batching gas-free nanopayments via BatchFacilitatorClient, and Circle Gateway bridge for chain-abstracted liquidity.
• Unlink — private transfers via the real @unlink-xyz/sdk client (createUnlink + unlinkAccount.fromMnemonic, primitives deposit/transfer/withdraw) plus ephemeral burner EOAs for unlinkable private nanopayments (shielded pool → burner → x402 → dispose).
• Twilio — SMS/WhatsApp claim-link delivery + Verify; this is what reaches recipients who don't have a wallet yet and solves the cold-start problem.
• Telegram — live bot webhook (/api/telegram) that parses natural-language payment intents and replies in-chat, sharing the same orchestrator as Twilio.

On-chain, PearPayEscrow.sol is deployed on Arc Testnet at 0x065484A8DAc3A9c3288b9C575a54947B0A1bC7eB — a programmable USDC/EURC escrow (conditional release behind a keccak256 claim-secret, time-based auto-refund, sender cancellation, optional arbiter dispute resolution).

Hacky / notable bits:

• A "rail selector" replaces cross-chain bridging — Pear Pay treats Arc/Unlink as one settlement surface and picks the best one, while still abstracting chains away from the user.
• Claim links unfurl as rich payment cards in iMessage via a dynamic Next.js opengraph-image (1200×630) generated per pay-link.
• "Pay with Face ID" uses WebAuthn passkeys (@simplewebauthn) for biometric approval in the browser and bootstraps Dynamic Delegated Access.
• Agent-to-agent payments use HTTP 402 / x402 with Dynamic server wallets or delegated MPC signing — no human in the loop after one Face ID grant.
• The joint private nanopayment flow (Unlink shield → ephemeral burner → Circle Gateway x402 on Arc) runs live via POST /api/privacy/nanopay and is visualized on the homepage in PrivateAgentRun.tsx.
• The "Try it" page is genuinely on-chain: wagmi + an injected browser wallet send a real Circle USDC transfer() on Arc Testnet (chain 5042002) with an Arcscan receipt — judges can verify an actual transaction with zero sponsor credentials.
• The Simulator is one reusable foundation: a shared PhoneFrame, a theme-aware on-screen IosKeyboard, and a shared PearPayCard, with each of the six channel components layering on its platform-native chrome and confirmation flow.
• Escrow persistence degrades gracefully: without ESCROW_DATABASE_URL the app uses an in-memory EscrowStore so production never crashes on missing Postgres.

The sponsor settlement rails (Arc/Unlink/x402) run on Arc Testnet for the demo so the full flow is reproducible without funded mainnet keys. Circle Gateway bridge can mint USDC onto Arc from a cross-chain pool (default source: Base Sepolia) when CIRCLE_API_KEY is set.