A sovereign wallet for a multi-chain, agent-paying internet.
Your keys stay on your machine. Your wallet pays for what it uses. Every claim here links to the code that makes it true.

PARSEC is a desktop wallet that treats your keys as yours alone. It is Algorand first, with Solana, Arweave, EVM / Base and Bitcoin beside it, and it is built so the part that can spend your money is small and inspectable: Rust signs and validates; the interface only asks. It opens on a live market, creates a wallet in three plain steps, registers .algo names, publishes to the permaweb, and pays for paid APIs over x402 — the HTTP status code that finally means something: 402 Payment Required.

PARSEC makes wallets for agents as readily as for people, and keeps a person in the loop where it matters.

Shiny on the outside; on the inside, an engineered movement you can open and read.

• Rust decides, TypeScript suggests. Signing for every chain pack and address validation run in Rust, and keys rest encrypted in the Rust vault. A signing command returns a signature, never a key.
• No UI framework. Vanilla TypeScript and one small DOM kit; no React, no wallet-connection SDKs, no chart libraries. The same build ships as the desktop app and as a permaweb site.
• An encrypted vault you can read the specification of. Argon2id key derivation and AES-256-GCM, with an optional LUKS cold volume ("the Tomb"). Vault specification · threat model
• Modular by contract. A new chain or tool is one module registration and one document. The module contract
• Designed for what comes after elliptic curves. Algorand is first because its accounts can move to Falcon-1024 keys while keeping the same address. QUANTUM.md

What it is. A server answers a request with 402 Payment Required and a PAYMENT-REQUIRED header describing exactly what it will accept: the price, the asset, the address to pay, the network. The client builds and signs a payment, sends the same request again carrying it, and a facilitator verifies and settles it on chain. No account, no API key, no subscription — the payment is the authentication. That is what makes it a rail for agents: one with a key can buy something it has never seen, from a seller it will never meet again.

How PARSEC does it.

• Three rails, one client. Algorand (USDC, ASA 31566704 on mainnet), EVM (EIP-3009 transfer-with-authorization, with the EIP-712 digest built in Rust) and Solana (a partially signed transaction). A new chain is one registerRail().
• Gasless on Algorand. The payment is an atomic group: the payer's USDC transfer, plus a fee-payer transaction the facilitator signs. The payer needs USDC, not ALGO for fees.
• Built not to pay twice. Every wait is bounded; a payment sent to a server that then goes silent reports indeterminate, not failed — reporting failed is how a payer pays twice. The amount is validated before it becomes a number, and every receipt keeps the settled transaction id.
• Portable. The module talks to its host through three small ports — signing, storage, network — so any Algorand wallet can embed it: an algosdk.TransactionSigner is the signer, unchanged. Discovery reads the facilitator's Bazaar catalogue.

Use it in your own wallet or agent (github.com/parsec-wallet/x402):

import { createX402Client, algorandSigner } from './x402';

const x402 = createX402Client({
  signers: { avm: algorandSigner(address, transactionSigner) },   // use-wallet, AlgoKit, Pera, Defly
  approve: async (p) => confirm(`Pay ${p.quote.amountDisplay} ${p.quote.assetSymbol}?`),
});

const res = await x402.fetch('https://api.example.com/weather');   // pays the 402, retries, returns the 200

Find out what something costs without a key: await createX402Client().quote(url).

Sell with it. The same repository carries the seller half: a FastAPI dependency that answers 402 with the terms, verifies and settles through the facilitator, advertises each endpoint in the Bazaar catalogue, and prices every route from one hot-reloaded file:

@app.post("/names/algo", dependencies=[Depends(x402_required("/names/algo"))])
async def register_algo_name(order: NameOrder): ...

In PARSEC. The x402 desk probes and pays any resource (GET or POST with a JSON body) with an explicit Pay on rail picker; .algo Names pays its BANKON fee this way. Protocol and design · every export and error · usage recipes

PARSEC is alpha, and says so. What is open is listed, not hidden:

• The first mainnet x402 settlement through PARSEC is the next step; until then everything is verified against stubs, test shapes and live read endpoints, which is not the same as having settled.
• The second-generation vault format (wrapped keys, per-entry derivation, Rust-enforced auto-lock) is written and specified but not yet compiled in; today's auto-lock is a five-minute interface timer.
• PARSEC's destination is the cypherpunk4096 standard, which is binary: all of it or none. Two commitments are not met yet — zero runtime dependencies, and no floating point in any value path.

Language models and agents: start at llms.txt — what PARSEC is, where every document lives, and how to pay its endpoints.

sales@pythai.net · bankon.pythai.net · security reports: see SECURITY.md

_{PARSEC is built by BANKON. Licensed by component: GPL-3.0-or-later for everything that holds or uses a key, Apache-2.0 for the rest, MIT for the server-side AO processes — per path in REUSE.toml.}