The problem
You live in London. Your grandmother lives in a village back home. She has a basic phone, no
smartphone and no data. Sending her $50 today means agent fees, slow transfers, and a currency
that loses value while it waits.
Stablecoins fixed the money, but not the experience. They still ask for an app, internet, a gas
token, a seed phrase and a long address. Hundreds of millions of people have a phone but no
internet, and most people never get past the seed phrase.
With Kova, you send dollars to her phone number. She gets a text. She dials a short code, enters
her PIN, and checks or spends her dollars, with no app and no internet. You set her up once from
your Kova app: her number, a PIN, a daily limit, and a code Kova texts to her phone.
We believe that if you solve a real problem, people use the product. This is the one we chose.
What it does
- Send by link, to anyone. Share a link on WhatsApp: "Ada sent you $20.00, about €18.40".
The friend claims it with Face ID, or with email or Google (Privy), in under a second. The key
lives only in the link (after the
#), and an unclaimed link can be taken back.
- Their own currency. Amounts show in naira, euros, pounds and more, beside the dollars.
- Private notes. "For dinner" travels with the payment, sealed on the sender's phone for the
two of them (X25519, XChaCha20-Poly1305). Kova stores text it can't read.
- A shop inside the wallet. A stall page, a catalogue, a till (the phone becomes a terminal),
orders from the table, a stamp card with no sign-up, and the day's takings live. Private
takings pay each sale to a one-time address, so nobody can add up a shop's sales.
- Kova for Business. Private payroll and supplier payments, each checked on Monad.
- Deposits from other chains. MON on Monad and tokens from other networks convert into dollars
through Relay. See setup and verification.
- Naira in and out. Add money in naira and cash out to a Nigerian bank through Paystack
(test mode on testnet).
- From guest to Kova. Someone who paid a shop with email or Google can keep their change in a
new Kova wallet, gas-free.
- Also: Kova Travel (flights and hotels in dollars), "Snap your menu" (a photo becomes catalogue
items), and spending insights. A US account number, a dollar card and savings are built behind
partner keys and show "Request access" until a partner switches them on.
How it works for a phone with no internet
your Kova wallet ──signs──▶ Kova API ──relayer pays gas──▶ Monad: AUSD lands in her pocket
│
her phone ◀── text: "$1.00 arrived. Balance $9.25. Dial *384*53916#" (Africa's Talking SMS)
her phone ──dials *384*53916#──▶ Africa's Talking ──▶ Kova API: balance, pay a till, send
- Each phone number gets a pocket: its own address on Monad, holding AUSD, with a PIN and a
daily limit (at most $200). The pocket's key is sealed on Kova's server (AES-256-GCM), the PIN is
hashed (scrypt), and three wrong PINs lock it for 15 minutes.
- The wallet that set the pocket up can always take the dollars back, with no PIN, even if USSD
is paused.
- A spend is signed from the pocket as an EIP-3009 authorization and relayed like any other Kova
payment. Each USSD session pays once, however many times the network resends a screen.
- Sending to a number Kova doesn't know holds the dollars at a one-time address, texts an invite,
and lets the sender take them back until they're claimed.
- Code:
ussd.ts, pockets.ts,
phone-payments.ts,
arrival-sms.ts.
Today this runs on Africa's Talking's simulator with test dollars. Next: a live USSD code per
country, and cashing out to mobile money (M-Pesa, MTN MoMo) from the same menu.
How Kova uses Monad
- Payments are signatures. The payer signs an EIP-3009
transferWithAuthorization for AUSD.
Kova's relayer submits it and pays the gas, so nobody holds MON.
- One round-trip to paid. The relayer estimates gas, counts its nonce locally, signs and sends
with
eth_sendRawTransactionSync, so the receipt comes back with the send: about 0.4 to 0.5 s on
the server, about a second from tap to paid on a phone in Lagos.
- Why Monad. Finality fast enough for a checkout line, and gas cheap enough for Kova to pay it
for every user. That's what makes a dollar app with no gas token possible. It also makes privacy
affordable: a fresh address for every private payment, and a transaction to spend each one.
- Charges carry their reference on-chain. A checkout's reference rides in the authorization's
nonce, so Kova's chain watcher settles a payment whoever submits it.
- Limits live on Monad.
KovaCard holds each spending key's daily limit, freeze and cosigner,
so the limit is kept by the contract, not by Kova's database.
- Names on Monad.
ada.nad comes from Nad Name Service on Monad mainnet. A pasted address
shows its own .nad name only when that name points back to it.
- Privacy by permission. Private payments use ERC-5564 stealth addresses
(
stealth.ts), each posted to the standard announcer so any
wallet can find its payments from the chain alone. The sender's memo is sealed for the
recipient's viewing key. The amount is public; who it went to isn't.
- Exchange rates from Chainlink CRE. A workflow (
apps/rates) checks two FX
sources against each other, reaches consensus and writes a signed report to KovaRates on Monad
testnet. Mainnet uses a fixed reference table, labelled as such.
Who's using it
mykova.app/stats counts Kova's users live, straight from Kova's
database on each network, and refreshes every minute. It shows people, payments, money moved,
shops, links and where new people came from. It counts totals only, never who someone is.
On 23 October 2026:
| Mainnet | Testnet |
|---|
| People with a Kova wallet | 12 | 162 |
| Payments | 0 | 36 ($402.55 in test dollars) |
| Shops open | 2 | 21 |
| Links sent | 1 | 7 (4 claimed) |
These counts include our own testing, and the page says so. A person is a wallet that did
something only Kova wallets do: made its passkey backup, published a note key, took test dollars,
paid a Kova charge, sent or claimed a link, or opened a shop. Kova's demo account, which App Review
signs into, is left out. The numbers come from apps/api/src/routes/stats.ts,
and anyone can read them at GET /v1/public/stats on each network's API.
Proof on Monad
Kova's API, relayer and contracts are live on mainnet. This week mykova.app runs the testnet
build, with free test dollars, for the phone-payment demo.
Mainnet (chain 143)
Testnet (chain 10143), one receipt per feature
| Feature | Receipt |
|---|
| $3.00 to a phone number with no apps, straight into its USSD pocket | 0xe7957e6d… |
| $1.00 more to the same phone, arrived in 1.37 s | 0xa77fb146… |
| A coffee, $4.50, with a $0.00 fee | 0x6a52a3cf… |
| $20 to a friend abroad, arriving as ≈ €18.40 | 0xa92a1733… |
| $20 sent by link and claimed by a brand-new wallet in 0.7 s | 0x7feaee54… |
| Paid with no signal, carried as a code, settled in 0.66 s | 0x84a1ffae… |
| Ordered and paid from table 3, $7.75 in 0.76 s | 0x61749899… |
| The sixth croissant, free with the stamp card: a $0.00 payment with its receipt | 0x73001c6d… |
| A private send's announcement, with its sealed memo | |
Architecture
flowchart LR
subgraph People
app["Kova app (iOS, Expo)"]
web["mykova.app (Next.js)"]
phone["Any phone (USSD, SMS)"]
end
subgraph Kova
api["Kova API (Hono)"]
db[("Postgres")]
watcher["Chain watcher"]
relayer["Relayer (pays gas)"]
end
subgraph Monad
ausd["AUSD (EIP-3009)"]
card["KovaCard (limits)"]
rates["KovaRates"]
nns["Nad Name Service"]
end
at["Africa's Talking"]
cre["Chainlink CRE"]
app -- "signed authorization" --> api
web -- "server-side calls" --> api
phone -- "*384*53916#" --> at -- "USSD callback" --> api
api -- "texts" --> at -- "SMS" --> phone
api --- db
api --> relayer -- "transferWithAuthorization" --> ausd
relayer --> card
watcher -- "reads transfers" --> ausd
watcher --- db
cre -- "signed report" --> rates
api -- "reads" --> rates
app -- "looks up names" --> nns
web -- "looks up names" --> nns
| Path | What it is |
|---|
apps/mobile | The Kova app (Expo, React Native): the wallet, and shop mode with the till. Installs with npm, outside the pnpm workspace. |
apps/web | mykova.app (Next.js): the web wallet (/wallet), shop mode (/dashboard), pay pages, stall pages and request links. Every API call is made server-side. |
apps/api | The Kova API (Hono on Node): checkout, relaying, the chain watcher, wallets, phone payments, USSD pockets, texts, shops and tills. |
apps/card | KovaCard, the contract behind every spending key (daily limit, freeze, cosigner), with Foundry tests. |
apps/rates | The Chainlink CRE workflow and the KovaRates contract (Foundry). |
packages/monad | Shared chain logic: networks and tokens, EIP-3009 authorizations, stealth addresses, sealed notes, the privacy router, spending keys, offline payments, phone payments and .nad names. |
packages/db | Postgres schema and migrations (Drizzle). |
packages/tempo | From the earlier Tempo build (see below); the Monad build doesn't use it. |
|
Built with TypeScript · Monad · viem · AUSD by Agora ·
passkey wallets with Mera (WebAuthn PRF) ·
Hono on Node 22 · PostgreSQL with Drizzle ·
Next.js 16 and React 19 · Expo SDK 54 ·
Africa's Talking (USSD and SMS) · Privy ·
Relay · Nad Name Service · Chainlink CRE ·
Foundry · Railway · Vitest · Biome ·
Remotion and ElevenLabs for the films.
Run it
You need Node 22.12+, pnpm 10, PostgreSQL 16, and Xcode for the iOS app.
git clone --recursive https://github.com/Cybire1/kova && cd kova
pnpm install
API (http://localhost:4000; migrations run on start):
cp apps/api/.env.example apps/api/.env
createdb kova_dev
pnpm --filter @kova/api setup:dev # 1st run: generates a relayer key into apps/api/.env.monad
# fund that relayer with testnet MON at https://faucet.monad.xyz, then:
pnpm --filter @kova/api setup:dev # 2nd run: creates a demo shop and prints its API key
pnpm --filter @kova/api dev
Test dollars and payments need test AUSD in the relayer. Agora's testnet faucet
(0xd236c18D274E54FAccC3dd9DDA4b27965a73ee6C) gives 10,000 per address when it has funds; when
it's empty, send test AUSD to the relayer's address.
Web (http://localhost:3000):
cp apps/web/.env.example apps/web/.env.local # KOVA_API_URL=http://localhost:4000, a SESSION_SECRET
pnpm --filter @kova/web dev
iOS app:
cd apps/mobile
npm install
cp .env.example .env # EXPO_PUBLIC_KOVA_MONAD_API_URL=http://<your Mac's LAN IP>:4000 on a phone
npx expo run:ios
Tests: CI (.github/workflows/ci.yml) runs typecheck, lint, the
unit tests, the API suite against Postgres, the website build, the iOS app's typecheck and the
contract tests on every push. AGENTS.md lists the same commands to run
locally.
Deploy: the API and web app ship as Docker images (Dockerfile,
Dockerfile.web) on Railway, with the same variables as the .env.example files.
In production the relayer key belongs in a KMS.
Built during Metropolis, and since
All of Kova was written during the Metropolis build window (1 September to 13 October 2026). It
began on 19 September as a Tempo build for Colosseum's Crypto World's Fair (branch main, until
23 September): the API's foundation, the database schema, payment intents, the merchant dashboard
and the first app screens. The Monad build moved Kova to Monad and added payments by signature
with sponsored gas, the chain watcher, passkey wallets with Mera, the web wallet, the shop inside
the wallet, wallet sign-in, email and Google with Privy, Chainlink CRE rates, spending keys, private
payments, offline payments, Kova Travel and the launch film.
Since the submission (14 October on), during judging: payments to phone numbers, USSD pockets
and arrival texts with Africa's Talking, sending to .nad names, private dollars in one balance,
deposits from other chains through Relay, MON conversion, Google sign-in, the TestFlight beta, and
CI on GitHub Actions. Every commit is dated in the history.
AI disclosure
Kova was built with AI coding tools. Most of the code, tests and documentation, and the films'
code, were written with Claude Code (Anthropic's Claude models)
under the team's direction and review. The films' voiceovers were generated with ElevenLabs. At
runtime, two optional features call AI models: "Snap your menu" (Claude or DeepSeek) and spending
insights (TypeSafe's Jev).
Attribution
Kova builds on open-source software, each under its own licence, including:
viem, Mera,
@noble and @scure
cryptography, Hono, Drizzle ORM,
Zod, Next.js,
React, Expo and
React Native, the Privy
SDK, the Chainlink CRE SDK, Foundry,
Remotion (Remotion licence), Vitest
and Biome. The Manrope
typeface is under the SIL Open Font License. AUSD is Agora's; exchange-rate sources are
open.er-api.com and the fawazahmed0 currency API.
Kova is MIT licensed.
