PURSER

01 / OVERVIEW

Purser is Cash App for USDC: a stablecoin wallet built for normal people, not crypto users. Users sign in with Face ID, get an @username, and send, request or split dollars with anyone in the world. No addresses, seed phrases, gas or tickers.

Underneath, every account is a Stellar smart account and every payment is USDC on Stellar. Purser is built on four open-source Soroban building blocks that any Stellar wallet can reuse:

• Passkey smart accounts with sponsored fees, so users never hold XLM.
• Username registry: @handles for smart accounts, bridged to SEP-2 federation.
• Claim-link escrow: pay a phone number or email before the recipient has an account.
• Requests and splits: on-chain payment requests any app can show and pay.

Cash in and out runs through Stellar anchors (SEP-10, SEP-12, SEP-24).

02 / WHY STELLAR

Stellar is not storage here: accounts, balances, payments, escrow, requests and settlement all run on-chain.

03 / SYSTEM ARCHITECTURE

 ┌──────────────────────────────────────────────────────────────┐
 │                    PURSER APP (iOS / Android / Web)          │
 │   Face ID passkey · @usernames · send · request · split      │
 └──────────────┬───────────────────────────────┬───────────────┘
                │ signed auth entries           │ SEP-10/12/24
                ▼                               ▼
 ┌──────────────────────────────┐   ┌──────────────────────────┐
 │  PURSER BACKEND              │   │  STELLAR ANCHORS          │
 │  · Relayer (fee-bump, pays   │   │  · deposit (bank/card →   │
 │    all network fees)         │   │    USDC)                  │
 │  · SEP-2 federation server   │   │  · withdraw (USDC → local │
 │  · Indexer (contract events) │   │    currency / mobile)     │
 │  · Phone/email OTP service   │   └─────────────┬────────────┘
 └──────────────┬───────────────┘                 │
                │ submits Soroban txs             │ USDC payments
                ▼                                 ▼
 ┌──────────────────────────────────────────────────────────────┐
 │                   STELLAR NETWORK (Soroban)                  │
 │                                                              │
 │  [Smart Account]──owns──▶[Username Registry]                 │
 │   passkey signer          @handle → C-address                │
 │        │                                                     │
 │        ├──USDC──▶[Claim Escrow]    phone/email claim links   │
 │        ├──USDC──▶[Requests/Splits] on-chain requests         │
 │        └──USDC──▶ any Stellar address / other Purser user    │
 │                                                              │
 │  USDC (Stellar Asset Contract)                               │
 └──────────────────────────────────────────────────────────────┘

Components

04 / CONTRACT INTERFACES

All contracts are written in Rust for Soroban and released under Apache-2.0, with a TypeScript SDK.

// Username registry
fn register(env, owner: Address, handle: String)        // owner.require_auth()
fn resolve(env, handle: String) -> Option<Address>
fn reverse(env, account: Address) -> Option<String>
fn transfer(env, handle: String, new_owner: Address)    // owner.require_auth()
fn release(env, handle: String)
// rules: lowercase a-z0-9_, 3-20 chars, reserved-name list, one handle per account

// Claim escrow
fn create(env, sender: Address, token: Address, amount: i128,
          claim_hash: BytesN<32>, expiry: u64) -> u64     // returns claim id
fn claim(env, id: u64, secret: Bytes, recipient: Address)
fn refund(env, id: u64)                                  // after expiry, to sender

// Requests and splits
fn request(env, payee: Address, payers: Vec<Address>,
           amounts: Vec<i128>, memo: String) -> u64
fn pay(env, id: u64, payer: Address)                     // payer.require_auth()
fn cancel(env, id: u64)                                  // payee only
fn status(env, id: u64) -> RequestStatus

Every state change emits a contract event (registered, claimed, refunded, paid), which feeds the indexer and on-chain metrics.

05 / KEY FLOWS

A. Sign up

• User creates a passkey with Face ID; the app derives the public key.
• Relayer deploys a smart account with that passkey as signer and pays the fees.
• User picks @handle; registry stores handle → account. The USDC balance is ready with no XLM held.

B. Send $40 to @maria

• App resolves @maria through the registry.
• User approves with Face ID; the passkey signs the auth entry for a USDC transfer.
• Relayer wraps it in a fee-bump transaction and submits. Settled in ~5 seconds.

C. Pay someone who isn't on Purser yet

• Sender enters a phone number or email. App creates a random secret and calls create with its hash and a 14-day expiry.
• Recipient gets a link with the secret, verifies by OTP, signs up with a passkey and calls claim.
• If unclaimed by expiry, refund returns the USDC to the sender.

D. Cash out to local currency

• App authenticates to the anchor with SEP-10, passes KYC through SEP-12, and opens the SEP-24 withdrawal flow.
• User sends USDC to the anchor; the anchor pays out to bank or mobile money.

06 / SECURITY & MONITORING

A full threat model and on-chain monitoring plan follow Stellar's developer templates. Monitoring alerts on unusual contract events, relayer spend and failed claims.

07 / ON-CHAIN METRICS

Purser publishes its contract IDs, so growth is verifiable on-chain:

• Smart accounts created through Purser
• USDC payments: count and volume through Purser contracts
• Claim links created and claimed, and the share claimed by new users
• Countries with a completed anchor cash-out

08 / TEAM