Spare crypto, explained end to end.

Change watches the crypto you already spend, rounds each payment up to the next dollar, and collects the difference once a week. The merchant is always paid the real price — the round-up comes from you, on purpose, when you approve it.

The product is built in public and not finished. Here is exactly where it stands.

1. 1Open your account and connect a wallet — Phantom, MetaMask, Coinbase Wallet or Solflare.
2. 2Sign the message your wallet shows. It proves the wallet is yours. No gas, no password.
3. 3Tick the recent payments that were purchases. Round-ups are read from the blockchain, not typed in.
4. 4Approve one USDC transfer for the week's total. We verify it on-chain and record it.

An $18.42 payment becomes $19.00. The $0.58 is the product. You choose whether the target is the next $1, $5 or $10 — a bigger rule fills the jar faster.

Round-ups are collected weekly rather than per purchase, because one signature a week costs one set of network fees instead of fifty.

The browser holds your wallet and nothing sensitive. Every read of the blockchain, every price lookup, and every sweep check happens on the server, so API keys and verification logic never ship to the page.

Connecting a wallet grants a read. Change pulls your recent outgoing payments — native ETH and USDC on Ethereum and Base, SOL and USDC on Solana — prices each one in dollars at the time of the scan, and works out the leftover.

Solana needs a different approach from Ethereum. Rather than guessing from instructions, we compare your token balance before and after each transaction, which catches payments made through any program, including swaps and payment apps.

GET /api/activity?evm=0xabc…&sol=7WU9…&rule=1

{
  "spends": [
    {
      "chain": "solana",
      "asset": "USDC",
      "paidUsd": 214.58,
      "roundUp": 0.42,
      "counterparty": "HWznbZ…DYmk"
    }
  ],
  "pendingRoundUp": 1.96
}

Results are cached for 30 seconds per wallet set. Public Solana endpoints are rate limited, so a dedicated RPC key makes scans more reliable.

The rule is deliberate about round numbers: a payment that lands exactly on the target still steps up a whole increment, so spare change is never zero.

export function roundUpAmount(paid: number, rule: 1 | 5 | 10) {
  const cents = Math.round(Math.max(0, paid) * 100);
  const step = rule * 100;
  const rem = cents % step;
  const extra = rem === 0 ? step : step - rem;
  return extra / 100;
}

Everything is held in whole cents. Money never touches floating-point maths on the way to a total.

One swap a week turns your round-ups into SPYx. You sign it in your own wallet, and the token arrives in that same wallet. Change never takes custody, never holds a balance, and has no allowance over your funds.

Jupiter routes the trade across Solana liquidity. You see the expected amount, the price impact and the maximum slippage before you approve anything.

POST /api/swap/quote   → what $5.00 buys right now
POST /api/swap/build   → an unsigned transaction for your wallet
POST /api/swap/send    → broadcast what you signed
POST /api/swap/record  → read the finished swap back off the chain

The recording step is the one that matters. The server re-reads the transaction and compares your token balances before and after, so the amounts written down are the amounts that actually moved. A client that invents a number gets rejected.

Round-ups are small by design, which is exactly why they need time rather than attention. Hover the chart to read any year.

The rule you pick decides how fast the jar fills. Same habit, three speeds.

These paths assume a steady 8% a year, which no real market delivers. Long-run US equity returns have historically landed in that neighbourhood with severe drawdowns along the way. Nothing here is a forecast or advice.

Every round-up buys SPYx, a tokenized product that tracks the S&P 500, issued by Backed. It is an SPL token on Solana, and it lands in your own wallet — Change never holds it.

Because it is a token rather than a share, what you hold is the issuer's instrument tracking the index, under their terms. Tokenized stocks are not offered in every country, and the app checks before quoting a swap.

Signing in means signing a sentence. The server issues a one-time code, your wallet signs a message containing it, and the signature is verified against the address — Sign-In with Ethereum on EVM chains, Ed25519 on Solana. Smart-contract wallets are verified on-chain, so Coinbase Smart Wallet and similar work too.

• No seed phrase, private key or password is ever requested or stored.
• The session is a signed, http-only cookie. A stolen copy of the page cannot read it.
• Sign-in codes expire in ten minutes, and the message names the site to stop replays elsewhere.
• Round-up amounts always come from the chain, never from the browser.
• Change is not a broker-dealer and holds no shares. Booked sweeps wait for a partner.

No names, emails or phone numbers are collected to use the product. If the site is running without a database, that same information stays in your browser instead and never reaches a server.

Every route is server-rendered and returns JSON. Routes that touch an account need the session cookie; the activity scan is public because it only reads public chain data.

Next up, in order: automatic swaps with a weekly cap so nothing needs approving, more tokenized assets beyond the S&P 500, and a stablecoin card that rounds up at checkout.

Where machine learning fits — planned, not live today

Tagging purchases by hand is the honest version of a hard problem: on-chain, paying a shop and topping up an exchange look identical. Each tag you make is a labelled example, which is what any future model would learn from.