aeron-wallet
OfficialIt is an MCP server that lets an agent manage a non-custodial USDG wallet on Robinhood Chain and pay x402/402-Payment-Required APIs automatically.
get_address – Print (or create on first run) the wallet address to fund with USDG.
get_balance – Read the wallet’s ETH and USDG balances.
pay – Call an x402 endpoint, read the 402 challenge, and pay in USDG if needed; supports GET/POST, JSON bodies, and budget caps.
history – Show recent payments from the local log (default 10, up to 50).
create_session – Mint a scoped session with allowed hosts, total budget, per-call cap, and TTL.
list_sessions – Show every session, its spending, and whether it is still live.
revoke_session – Kill a session so it stops paying on its next call.
Sessions restrict what hosts an agent can pay and cannot widen the wallet’s own caps.
The wallet is non-custodial: the key stays on the machine, never leaves it, and payments settle through the facilitator without needing ETH.
Provides an on-chain wallet for agents to hold USDG and pay x402 endpoints on Robinhood Chain, with tools for checking balances, sending payments, and reviewing transaction history.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@aeron-wallet Pay the x402 request to inference.aeron.sh with the DeepSeek chat completion body."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
aeron-wallet
A non-custodial wallet for agents. It holds USDG on Robinhood Chain and pays
402 Payment Required responses on its own, so an agent can call a metered API
without a card, an account, or a human in the loop.
Ships two ways: a CLI, and an MCP server for Claude and other MCP clients.
Quickstart
npx -y aeron-wallet addressThat prints your wallet address and creates a key on first run. Send USDG to that address, then pay for a call:
npx -y aeron-wallet pay https://inference.aeron.sh/v1/chat/completions \
'{"model":"deepseek/deepseek-chat","messages":[{"role":"user","content":"hi"}]}'The wallet reads the 402 challenge, checks it against your budget caps, signs an EIP-3009 transfer, and retries the request with the payment attached. You do not need ETH: the facilitator relays the transaction and pays gas.
Related MCP server: PipRail
Commands
Command | What it does |
| Print the wallet address. Creates the key if none exists. |
| ETH and USDG balances, read from chain. |
| Call an x402 endpoint, paying if it answers 402. POST unless told otherwise. |
| The last 10 payments, from the local log. |
| Mint a scoped session: hosts, budget, per-call cap, expiry. |
| Every session, what it spent, and whether it is still live. |
| Kill a session. It stops paying on its next call. |
| Run as an MCP server over stdio. The default with no arguments. |
Install it in an agent
Claude Code
/plugin marketplace add aeronlabs/aeron-wallet
/plugin install aeron-wallet@aeronlabsCursor
Gemini CLI
gemini extensions install https://github.com/aeronlabs/aeron-walletVS Code
code --add-mcp '{"name":"aeron-wallet","command":"npx","args":["-y","aeron-wallet","mcp"]}'Anything else that speaks MCP
{
"mcpServers": {
"aeron-wallet": {
"command": "npx",
"args": ["-y", "aeron-wallet", "mcp"]
}
}
}Four tools: get_address, get_balance, pay, history. An unbound server
also gets create_session, list_sessions, and revoke_session.
Sessions
A session is a scope you can hand to an agent without handing over the wallet. It names the hosts that may be paid, a total budget, a per-call cap, and an expiry:
aeron-wallet session create --host inference.aeron.sh --budget 0.25 --ttl 2hThat prints a token, once. Bind a server to it and every call through that server inherits the scope:
{
"mcpServers": {
"aeron-wallet": {
"command": "npx",
"args": ["-y", "aeron-wallet", "mcp"],
"env": { "AERON_WALLET_SESSION": "<token>" }
}
}
}A bound server deliberately has no session tools. An agent that could mint itself a wider session would not be contained by one. It also cannot reach a host outside the scope: the wallet refuses before the request goes out, so an agent talked into paying an attacker's endpoint never contacts it.
Revoking takes effect on the next call, including for a server already running, because the scope is re-read every time rather than captured at startup.
aeron-wallet pay --session <token> <url> applies a scope to a single call.
Sessions narrow the wallet; they never widen it. The caps below still apply underneath, so a $5 session on a $1/day wallet spends $1 a day.
Your key
The key is generated on your machine on first run and written to
~/.aeron/wallet/key with 0600 permissions. It never leaves the machine and
nobody else can derive your address. Every install creates a different wallet.
Two consequences worth planning for:
Ephemeral containers. If
$HOMEis wiped between runs, the wallet regenerates and any USDG left on the old address is stranded. Mount a volume for~/.aeron, setAERON_WALLET_DIRto a path that persists, or supply the key yourself withAERON_WALLET_KEY.Hot wallet. The key sits unencrypted on disk so an agent can sign without a prompt. Keep the balance small. Fund it the way you would top up a prepaid card, not the way you would fund savings.
Budget caps
The wallet refuses to sign above either cap, so a loop cannot drain it.
Variable | Default | Meaning |
|
| Largest single payment. |
|
| Total for the current UTC day. |
Paying merchants you did not write
Reading a 402 sounds like one line — take accepts[0] from the body — and that
line works against servers written the same way this wallet was. It works
against almost nothing else. On a survey of the machine-payable endpoints
listed on Robinhood Chain, not one merchant put this rail's offer first:
every one of them leads with Base, and the payable entry sits somewhere down a
list of a dozen.
So the offer is searched for, not assumed, across every shape merchants actually use:
What differs | What is done |
Offers in the JSON body, or in a base64 | Both are read, and the same offer stated twice is one offer |
The amount is | Either is accepted |
The list mixes chains and address formats this wallet has no key for | Non-EVM entries are skipped rather than treated as errors |
Several offers are payable | The cheapest one wins |
Nothing is payable | The refusal names what was offered, so the reason is actionable |
The two protocol versions are not a version number
v1 carries the payment in X-PAYMENT and names the scheme and network at the
top level. v2 carries it in payment-signature, names neither, and states the
chosen offer verbatim in accepted — a rebuilt copy does not match, because
the server compares it against what it advertised. Answering a v2 merchant in
v1's form does not degrade; it is refused.
Worse, the split is not clean in the wild: merchants advertise a v2 header
beside a v1 body, and one host in a family of five wants X-PAYMENT while its
siblings want payment-signature. So the payment is offered in the form the
version asks for and, if that is refused outright, in the other one. Both
carry the same signed authorization, whose EIP-3009 nonce can be spent
exactly once — so the fallback cannot pay twice, however the server answers.
What a result means
A request that comes back 4xx is not one situation, it is three, and they
differ in the only way that matters: whether the money left the wallet. The
signal is the settlement receipt — a service that settled returns
X-PAYMENT-RESPONSE with a transaction hash, and one that did not, does not.
| Charged | What happened |
| yes | The service answered. |
| no | HTTP 402. The service refused the payment; the authorization is unspent. |
| no | The service returned an error and declined to charge — usually its own upstream failed. |
The case worth naming: a settled row with a reason means the money
moved and nothing came back. That is the only outcome where the wallet is out
of pocket for nothing, so it is reported as itself rather than folded in with
refusals that cost nothing.
Only settled counts against DAILY_CAP_USD. A refusal and an upstream
failure leave the balance untouched, so neither eats into the cap.
reason quotes the service's own message when it gave one, instead of a
generic phrase — an agent operator reading a log needs to know whether to
retry, top up, or fix the seller.
Configuration
Variable | Default |
|
|
|
|
|
|
|
|
| unset. Overrides the stored key. |
| unset. Binds the whole process to one session. |
Releases
Published from a tag by GitHub Actions using npm trusted publishing, so no
long-lived npm token exists to leak and every tarball carries a provenance
attestation: proof of the commit and workflow it was built from. Verify with
npm audit signatures after installing.
Where payments go
Payments settle on Robinhood Chain mainnet in USDG through the Aeron
facilitator at x402.aeron.sh. The wallet works with any x402 endpoint on the
same network, not only Aeron's.
More at aeron.sh/wallet.
Available Tools
7 toolscreate_sessionA
Create a scoped session: allowed hosts, a total budget, a per-call cap, and an expiry. Returns a token that binds an agent to that scope.
Inputs: ttl (required), hosts (required), budgetUsd (required), maxPerCallUsd.
get_addressB
The wallet address on Robinhood Chain. Fund it with USDG to pay for services.
Inputs: no named parameters.
get_balanceA
ETH and USDG balances of this wallet.
Inputs: no named parameters.
historyC
Recent payments made by this wallet.
Inputs: limit.
list_sessionsA
Every session, with what it has spent and whether it is still live.
Inputs: no named parameters.
payB
Call a machine-payable (x402) endpoint and pay in USDG if it answers 402. Budget caps apply.
Inputs: url (required), body, method.
revoke_sessionB
Revoke a session by id. It stops paying on its next call.
Inputs: id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool targets a distinct concern: wallet address, balances, payment execution, payment history, and session lifecycle. There is no meaningful overlap between payment history and session listing because one is about transactions and the other about scoped spending sessions.
Most tools follow a clear verb_noun pattern: get_address, get_balance, create_session, list_sessions, revoke_session. The single exception is 'history', which is a noun rather than a verb-led name like 'get_history' or 'list_payments'.
Seven tools is well-scoped for a wallet and session-management server. Each tool earns its place and the size is neither bloated nor overly thin.
The core wallet capabilities and session lifecycle are covered: address, balance, payment, history, create, list, and revoke. Minor gaps remain, such as no way to retrieve full session configuration details or individual payment records, but agents can work around this with the current surface.
Related MCP Connectors
Machine-payable API infrastructure for autonomous agents. Per-call x402 settlement in USDC.
Let an AI agent find and pay for x402 APIs and products in USDC on Base, within owner-set limits.
x402 pay-per-call APIs over MCP, settled in USDC on Base for autonomous agents and developers.
x402 layer for AI agents: 35 pay-per-call resources, x402 service discovery, USDG/USDC.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceBudget & cost control for AI agents: hard per-agent spend caps, rate limits, idempotency, and human-in-the-loop approval — enforced before each LLM call, not after the invoice. One hosted MCP endpoint (no proxy or self-hosting), settled via x402 (USDC on Base).MIT
- AlicenseAqualityAmaintenanceA budget-bound x402 payment wallet for AI agents: it autonomously pays HTTP 402 payment-gated URLs across every major chain (EVM, Solana, and many non-EVM families). Self-custodial and backendless, your key, your RPC, with spend caps enforced before any on-chain send.810MIT

@hpp-io/x402-mcp-bridgeofficial
AlicenseNot gradedqualityBmaintenanceEnables AI agents to autonomously pay for and discover services using HPP USDC.e over the x402 protocol, without API keys or manual signing.695 npmApache 2.0
@bridgenode/mcpofficial
AlicenseAqualityBmaintenanceEnables AI agents to make pay-as-you-go AI inference requests through x402 with automatic Solana USDC payments, no API keys or registration, while enforcing configurable spending limits.382 npm1MIT No Attribution