Xona Wallet
Ships as the npm package
@xona-labs/xpay, thexpayCLI, and thexpay_*MCP tools. The package and command names are unchanged.
Power your agent
पब्लिशर की अपनी कमांड। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
npx -y @xona-labs/[email protected]Claude Code में लोकल कमांड के लिए इंस्टॉल लिंक नहीं है। नीचे दी गई कमांड कॉपी करें और टर्मिनल में चलाएँ।
claude mcp add xona-labs-xpay -- npx -y @xona-labs/xpay@0.2.41टर्मिनल में चलाएँ।
{ "mcpServers": { "xona-labs-xpay": { "command": "npx", "args": [ "-y", "@xona-labs/[email protected]" ] } }}claude_desktop_config.json
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
Ships as the npm package
@xona-labs/xpay, thexpayCLI, and thexpay_*MCP tools. The package and command names are unchanged.
Xona Wallet: agent wallet and payment rail for agentic commerce. Multi-network wallet, x402 payments, AgenC marketplace hires, 20k+ services via PayAI and other catalogs
Agentic-commerce wallet. Multi-network USDC wallet, x402 payments, AgenC marketplace hires, and discovery across 20,000+ services - as a CLI, an SDK, and an MCP server.
npm install -g @xona-labs/xpay
xpay init # creates Solana + EVM keys, encrypted
xpay discover "research API" # 21k x402 catalog + AgenC agent listings, ranked
xpay pay https://api.example.com/x402 # x402 one-liner
xpay agenc hire <listingPda> # hire an on-chain agent (SOL escrow)
xpay token find BONK # find any Solana token by ticker or mint
xpay swap 0.5 SOL BONK # swap in your own wallet via Jupiter
xpay transfer 5 USDC 7G73PL...gC # direct USDC transfer
xpay balance # unified across networks
xpay report # daily / weekly / monthly report via OrbitX402
// SDK - same primitives, programmatic
import { loadProfile, createXPay } from "@xona-labs/xpay";
const xpay = createXPay({ profile: await loadProfile({ passphrase }) });
const result = await xpay.do("translate this PDF to Japanese", { body: { file } });
Xona Wallet is the wallet and rail layer for agentic commerce. It hides x402, USDC, RPC, and multi-network routing behind a flat surface so agent builders (Claude / Codex / OpenAI / Gemini / your own) can find and pay for services without writing payment plumbing.
npm install -g @xona-labs/xpay # CLI + MCP server, system-wide
npm install @xona-labs/xpay # programmatic SDK in a project
xpay init
# ✔ Profile "default" created at /Users/you/.xpay/default
# Solana 7RB7frdxPc9vZtuyq6YfNoWTJcDZsE2AcXXV6qkpf5ph
# EVM 0xA5D93CDB2bD16b2d1d3d19D45dad3FaBb1023dfa
# ⚠ RECOVERY PHRASE - write this down NOW. We cannot recover it for you.
# 1. depend 2. guess 3. mercy 4. online
# ... (24 words)
Fund the addresses with a few dollars of USDC on Solana mainnet, Base, or both. Then:
xpay balance
xpay discover "image generation"
xpay pay https://orbisapi.com/proxy/image-alt-text-generator-api-1c9472
All commands run from a single profile. Switch with xpay accounts use <name>.
The CLI is a thin shell over the SDK - every command has a direct programmatic equivalent.
import {
createXPay,
initProfile,
loadProfile,
setProfileGuardrail,
} from "@xona-labs/xpay";
// One-time setup
const created = await initProfile({
name: "default",
passphrase: process.env.XPAY_PASSPHRASE!,
});
console.log(created.addresses); // { solana, evm }
console.log(created.mnemonic); // back this up; not persisted in plaintext
// Configure spending caps
setProfileGuardrail("default", {
maxPerTx: 0.5,
maxPerDay: 5,
allowedHosts: ["api.payai.network", "*.xona-agent.com"],
});
// Use
const profile = await loadProfile({ name: "default", passphrase: process.env.XPAY_PASSPHRASE });
const xpay = createXPay({ profile });
await xpay.discover({ query: "weather" });
await xpay.useByUrl("https://...");
await xpay.do("translate this PDF to Japanese");
await xpay.transfer({ amount: 1, to: "7G73PL...", token: "USDC" });
await xpay.report({ period: "weekly" }); // via OrbitX402 - no RPC calls from your code
await xpay.wallet.balance("solana");
Xona Wallet ships tool definitions for the three major LLM SDKs. Same handlers, different schema shapes.
import Anthropic from "@anthropic-ai/sdk";
import { createXPay, forClaude, loadProfile } from "@xona-labs/xpay";
const xpay = createXPay({ profile: await loadProfile({ passphrase }) });
const { tools, handlers } = forClaude(xpay);
const response = await new Anthropic().messages.create({
model: "claude-sonnet-4-5",
tools,
messages: [{ role: "user", content: "find a cheap weather API and call it" }],
});
for (const block of response.content) {
if (block.type === "tool_use") {
const result = await handlers[block.name]!(block.input as Record<string, unknown>);
// ... feed result back to Claude
}
}
forOpenAI(xpay) and forGemini(xpay) return the same handlers wrapped in vendor-specific schemas. See examples/claude-agent.ts for the full tool-use loop.
Xona Wallet is listed in the official MCP Registry
as io.github.xona-labs/xpay - registry-aware hosts can discover and
install it by that name. For everything else, drop Xona Wallet into the host's
config - no code, no keys, no xpay init. On first boot the agent is
given its own wallet automatically:
// ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"xpay": {
"command": "npx",
"args": ["-y", "@xona-labs/xpay", "mcp"]
}
}
}
That's the whole setup. The generated wallet's Solana address is printed to
stderr on first run - fund it with USDC and the agent can pay. It persists
under ~/.xpay and is reused on every later boot, so the address is stable.
The host sees the core tools: xpay_discover, xpay_use, xpay_do, xpay_transfer, xpay_balance, xpay_report, xpay_guardrail, xpay_token_find, xpay_swap, xpay_trending_tokens, xpay_trade_quote, xpay_trade, xpay_x_user, xpay_x_posts, xpay_zauth_reposcan, xpay_zauth_scan_status, xpay_shop_search, xpay_shop_quote, xpay_shop_lens, xpay_shop_lens_quote, xpay_rwa_find, xpay_trust_check, xpay_order_create, xpay_orders_list, xpay_order_cancel, xpay_orders_run, xpay_agenc_status, plus xpay_bento_status / xpay_bento_enable / xpay_bento_disable to manage the intent firewall. If you've linked a Sana key (see below), eight additional sana_* tools are also registered automatically.
Bring your own wallet instead - the wallet source order is existing profile → key env → auto-generate, so any of these overrides the generated wallet:
"env": {
"XPAY_SOLANA_SECRET": "<base58 key>", // use a wallet you already hold
"XPAY_PASSPHRASE": "<passphrase>", // or unlock/encrypt a profile
"XPAY_NO_AUTO_WALLET": "1" // or disable auto-generation entirely
}
On macOS, with biometric unlock enabled on a profile, the server shows one Touch ID dialog at startup instead of keeping the passphrase in host config.
See SKILL.md for a framework-agnostic guide to driving these tools from any agent.
Each profile is a directory under ~/.xpay/ with:
~/.xpay/
├── default/ (or any name)
│ ├── wallet.json BIP-39 seed, AES-256-GCM encrypted by default
│ └── config.json networks, guardrail, RPC overrides, link
└── cache/ disk cache of catalogs (auto-managed)
Override with XPAY_HOME=/some/path or xpay init --workspace for project-local profiles.
Skip typing the passphrase on every command - unlock with Touch ID instead:
xpay biometric enable # verifies your passphrase, then stores it Touch ID-gated
xpay balance # → Touch ID prompt instead of a passphrase prompt
xpay biometric status # availability + current state
xpay biometric disable # removes the keychain entry
How it works: the wallet's scrypt + AES-256-GCM encryption is unchanged. enable places the
passphrase in your login keychain, and a small native helper (compiled on first use to
~/.xpay/bin/, requires the Xcode Command Line Tools) releases it only after a
LocalAuthentication check. Biometrics never replace the passphrase - they gate access to it.
The unlock order for every command is: --passphrase flag → $XPAY_PASSPHRASE → Touch ID →
interactive prompt. Your passphrase keeps working everywhere and remains the only recovery
path - if Touch ID is unavailable (or the stored copy goes stale after a re-encrypt), the CLI
falls back to asking for it.
macOS asks once to allow keychain access for the helper - choose "Always Allow". It will ask again after package upgrades, since the helper is recompiled.
The guardrail runs before any signer is touched, so a misbehaving agent (or compromised LLM) cannot bypass it.
xpay guardrail set \
--max-per-tx 0.5 \
--max-per-day 5 \
--require-approval-above 1 \
--allowed-hosts 'api.payai.network,*.xona-agent.com'
maxPerTx / maxPerDay: apply to every paid call and direct transfers.allowedHosts: apply only to x402 calls (transfers go to addresses, not hosts).maxPerTx / maxPerDay: apply to every paid call and direct transfers.allowedHosts: apply only to x402 calls (transfers go to addresses, not hosts).requireApprovalAbove: calls ≥ threshold need explicit approval. In the CLI this is a
Touch ID prompt when biometric unlock is enabled, otherwise a y/n
confirm; in the MCP server it is Touch ID only (no terminal), so an agent's large payment
surfaces as a system dialog you physically approve. In the SDK, wire the
onApprovalRequired hook to whatever you like - push notification, biometric, webhook.Spend caps stop an agent spending too much - they can't tell a legitimate payment from a prompt-injected one. The optional Bento layer adds an AI intent firewall: every paid call and transfer is screened for malicious intent (prompt-injection, wallet-drain, intent-vs-execution mismatch) before signing. It runs inside the guardrail, right after the local caps pass.
xpay bento enable # prints the agent wallet address to register
xpay bento status # whether screening is active
xpay bento disable # turn off - falls back to local caps only
There's no API key - Bento authenticates with the wallet's own key. The one manual step is a
one-time, on-chain registration of the agent wallet at
app.bentoguard.xyz (log in with your owner wallet; until the agent
wallet is registered, payments are rejected with Agent not found).
Each screened call returns a verdict:
ALLOW: cleared; Xona Wallet signs as normal.BLOCKED: flagged as a critical threat; Xona Wallet throws before signing, no funds move.ESCALATED: ambiguous; Xona Wallet defers to your onApprovalRequired hook, or fails closed.Agents can manage it over MCP too: xpay_bento_status, xpay_bento_enable, xpay_bento_disable
(disable is the escape hatch when the wallet isn't registered yet).
Xona Wallet supports an optional integration with Sana - an agent-native card that lets your AI spend at the point of sale, anywhere Visa is accepted.
Activating it adds a second wallet surface to Xona Wallet: your on-chain USDC (xpay) for agentic x402 payments, and a Sana card (fiat) for everything else. The two compose naturally - an agent can top up the card from the Xona Wallet wallet when the balance runs low.
sana.bot/gateway/app/api-keys (scope: read:all covers everything read-only; add write:card for deposits and swaps).xpay sana link sana_live_...
xpay sana status # confirm it's stored
sana_* tools appear automatically alongside the standard xpay_* tools.Pass the API key to forClaude / forOpenAI / forGemini to include Sana tools in your agent loop:
import { createXPay, loadProfile, forClaude } from "@xona-labs/xpay";
const xpay = createXPay({ profile: await loadProfile({ passphrase }) });
const { tools, handlers } = forClaude(xpay, {
sanaApiKey: process.env.SANABOT_API_KEY,
});
// tools now includes both xpay_* and sana_* entries
Or set SANABOT_API_KEY in the environment - the MCP server picks it up without any code change.
xpay sana unlink # removes the key from the profile
The sana_* tools disappear from the MCP server on next restart.
AgenC is a Solana-mainnet marketplace where registered agents sell services with on-chain escrow. Its hireable listings appear in xpay discover alongside x402 services - but they execute differently, and xpay routes them automatically:
xpay discover "research" # AgenC listings show as “agenc escrow”, priced in ◎SOL
xpay agenc hire <listingPda> # confirm → escrow SOL → get a task PDA
xpay agenc status <taskPda> # poll: open → claimed → review → settled
The same smart routing works in the SDK and MCP - xpay.use(resource) / xpay_use detect the agenc-hire payment scheme and run the escrow flow, returning a receipt (task, txSig, explorer link) as data. Hires are made through AgenC's humanless entry point, which pins the task to CreatorReview - escrowed funds never auto-release without your acceptance.
Notes:
maxPerTx/maxPerDay before signing. If no price feed is reachable and caps are set, the hire fails closed.xpay agenc accept is planned.agenc: { rpcUrl, reviewWindowSecs, endpoint } in the profile, or XPAY_AGENC_ENDPOINT. Opt out of the discovery source with XPAY_DISCOVERY_SOURCES=orbitx402.Find any Solana token by ticker or mint address and swap into it from your own wallet - keyless, via Jupiter's meta-aggregator:
xpay token find BONK # price, mcap, liquidity, mint, ✓ verified / ⚠ unverified
xpay swap 0.5 SOL BONK # quote → confirm → execute (guardrail-gated)
xpay swap 1000 BONK USDC --slippage-bps 50
const tokens = await xpay.findTokens("BONK"); // ranked verified-first
const quote = await xpay.swapQuote({ amount: 0.5, from: "SOL", to: tokens[0].mint });
const result = await xpay.swap({ amount: 0.5, from: "SOL", to: tokens[0].mint });
Notes:
xpay token find shows the flag.maxPerTx / maxPerDay before signing - fails closed if the token can't be priced while caps are set. Swaps stay inside your wallet (no external recipient), so allowedHosts doesn't apply.--slippage-bps) or per profile (swap.slippageBps).JUPITER_API_KEY (or profile swap.apiKey) for higher limits; XPAY_JUPITER_ENDPOINT overrides the API base.xpay sana swap swaps inside a Sana-hosted wallet and needs a Sana API key.Before paying an unfamiliar service, check who is on the other end. Solana merchant wallets (the x402 payTo) are looked up in the 8004-solana registry, the Solana implementation of ERC-8004 Trustless Agents: an agent identity (Metaplex Core asset) plus on-chain client feedback, and optional ATOM scoring (trust tier, quality, confidence, risk). Free, read-only, no wallet:
xpay trust 28heAMpFkeUJsL7o7apiK4oJwZWq2fUHinRwbgYYsemG # identity, 0-100 feedback score, review count, SAID identity
xpay discover "token price" --network solana # each Solana result shows a trust line
xpay discover "data" --min-trust 50 # only registered merchants scoring >= 50
const trust = await lookupMerchantTrust(payTo); // { registered, agent: { name, avgScore, feedbackCount, atom? }, summary, said? }
const results = await xpay.discover({ query: "data", minTrust: 0 }); // resource.trust on each result
Notes:
agent_wallet or its owner. When several identities share a wallet, the strongest (ATOM tier, then review count, then score) is returned, with agentCount.avgScore is the average client feedback (0-100). ATOM quality is confidence-weighted, so it stays low until an agent accumulates feedback; don't read one as the other.--min-trust / minTrust over-fetches (50 candidates) and can still come back empty.8004-indexer-main.qnt.sh, keyless, 100 req/min per IP), one per unique wallet, cached 10 minutes including negatives. XPAY_8004_INDEXER overrides it; --no-trust / trust: false skips it. A failed lookup never fails discovery.trust.said (null = no SAID identity): verified, tier, badges and a 0-100 score. That score is SAID's composite of identity, activity and longevity signals, not client feedback, so an agent can score high with zero reviews; it is never merged with the 8004 avgScore, and --min-trust still filters on the 8004 score only. XPAY_SAID_API overrides the API base; a failed SAID lookup just leaves said unset.xpay_trust_check (free), and xpay_discover results carry trust plus an optional minTrust filter.List tradable real-world-asset tokens: RWA covers any tokenized off-chain asset, and what actually trades on Solana DEXes today is tokenized stocks/ETFs (Backed xStocks like TSLAx/SPYx, Ondo Global Markets like TSLAon/GLDon, Remora, Backpack Securities) plus the treasury-backed yieldcoin USDY. Free, read-only, no wallet:
xpay token rwa # full list, verified-first by liquidity
xpay token rwa tesla # matches TSLAx (Backed) and TSLAon (Ondo)
xpay token rwa --category treasuries # USDY
xpay swap 10 USDC TSLAx # swap into one (guardrail-gated)
const rwas = await xpay.findRwaTokens({ query: "nvidia" }); // NVDAx, NVDAon
Notes:
rwa/stocks/xstocks token tags (the tag endpoint itself doesn't accept these), so the list is Jupiter-verified and priced live. Results cache in-process for 5 minutes.xpay_rwa_find (free). Everything returned is swappable from USDC via xpay_swap / xpay swap.Recurring buys and conditional one-shots on tokenized stocks (xStocks and other Solana issuers), stored in the wallet profile so any agent framework can create them and any scheduler can run them:
xpay orders add buy 25 SPY --every weekly --budget 500 # $25 of SPYx every week, $500 total
xpay orders add buy 100 NVDA --max-premium 0.5 --market-hours # once, when the premium is <= 0.5% during US hours
xpay orders list # status, caps used, why an order is still waiting
xpay orders run --dry-run # what would fill right now, nothing signed
xpay orders run # execute due orders (cron: */15 * * * *)
await createStockOrder(profile.path, { side: "buy", stock: "SPY", amount: 25, every: "weekly", limits: { maxTotalUsd: 500 }, approved: true });
const report = await runDueOrders(profile.path, xpay, { maxPerDay: 200 });
How a run decides, per due order: expiry and caps, then market hours (if --market-hours), then the same checks as a direct stock trade (verified token, liquidity floor, adverse premium/discount vs the real share price, default 2%), then the profile's maxPerDay. Orders that don't qualify report why and wait for the next run; recurring orders keep their cadence and skip missed periods rather than catching up.
Safety model, since runs are usually unattended:
--budget and/or --max-fills; one-shots expire after 7 days by default.xpay_order_create saves an order as pending_approval; only xpay orders approve <id> (a human at the terminal) activates it. Agents can list, cancel and run, but a run only ever executes approved orders.maxPerDay is enforced from the persisted fill log, so separate cron invocations can't each spend a fresh daily allowance.needs_review; check the wallet, then xpay orders resume <id> (add --filled if it landed). A guardrail denial (per-tx cap, approval threshold) parks it in blocked. Only one run executes at a time.Unattended runs need the wallet unlocked: set XPAY_PASSPHRASE in the scheduler's environment (Touch ID can't prompt at 3am). Buys above requireApprovalAbove are denied without a TTY and block the order. MCP: xpay_order_create, xpay_orders_list, xpay_order_cancel, xpay_orders_run.
Trade the NOXA Fun memecoin scene on Robinhood Chain (Robinhood's Arbitrum L2, chain 4663) straight from your own wallet - no API key. NOXA Fun tokens launch into Uniswap V3 pools quoted in native ETH, so trading is plain on-chain V3: quote via QuoterV2, execute via SwapRouter02. Discovery (trending / new tokens, USD pricing) comes from GeckoTerminal's public API.
xpay trending # what's hot on Robinhood Chain (free, no wallet)
xpay trending --new # freshest launches (higher risk)
xpay trade 0.01 ETH 0x020bfc…18b4 # buy a token with native ETH → quote → confirm → execute
xpay trade 5000 0x020bfc…18b4 ETH # sell it back to ETH
xpay trade 0.01 ETH CASHCAT --quote-only # preview without trading (symbol resolved via trending)
const hot = await xpay.trendingTokens({ limit: 10 }); // symbol, address, price, volume
const quote = await xpay.tradeQuote({ amount: 0.01, from: "ETH", to: hot[0].address });
const result = await xpay.trade({ amount: 0.01, from: "ETH", to: hot[0].address }); // → { txHash, ... }
Notes:
maxPerTx / maxPerDay before signing - same boundary as xpay swap.unverified (memecoin tickers aren't unique - prefer passing the exact contract address). NOXA per-tx / max-wallet transfer caps are checked before signing: a buy that would breach one errors up front (instead of reverting on-chain), and the quote flags trades that come close.rpcs.robinhood.--slippage-bps) or per profile (trading.slippageBps).xpay balance lists your Robinhood Chain ETH plus every ERC-20 you hold (via the chain's Blockscout explorer), so tokens bought here show up automatically. Override the explorer with XPAY_ROBINHOOD_EXPLORER.xpay swap (Solana / Jupiter). GMGN was evaluated and skipped - it doesn't support Robinhood Chain.Agents can pull live X account data with zero setup - no X developer account, no API key. xpay pays xona's x402-gated proxy per call, which passes X's pay-per-use billing through at cost (no markup):
xpay x user jup_ag # profile: followers, bio, verification (~$0.01)
xpay x posts jup_ag # 10 recent posts + engagement metrics (~$0.06)
MCP: xpay_x_user / xpay_x_posts - the classic flow is token due diligence: xpay_token_find → check the project's X account → swap only if it holds up. Payments go through the normal x402 flow, so the guardrail caps apply. Endpoint override: XPAY_XDATA_ENDPOINT.
Scan any git repository for code provenance and vulnerabilities via zauth's x402-paywalled scanner (partner integration) - returns a zauth score (0–100) plus a markdown analysis. Only the scan kickoff is paid (~$0.05 USDC on Solana or Base) and the guardrail caps apply (if your profile restricts allowedHosts, add api.zauth.inc). Status checks are free and need no wallet:
xpay zauth reposcan https://github.com/owner/repo # paid: starts the scan (or returns a cached report)
xpay zauth status <sessionToken> # free: poll a still-running scan
A scan either returns a cached report immediately or { status: "scanning", scanId, sessionToken }; xpay polls the free status endpoint automatically and hands you the sessionToken if the scan outlives the wait window. Follow up with the sessionToken (the JWT, valid ~1 hour) - not the scanId.
MCP: xpay_zauth_reposcan (paid, polls up to ~90s) / xpay_zauth_scan_status (free follow-up). Endpoint override: XPAY_ZAUTH_ENDPOINT.
Search products across Google Shopping, Amazon, and eBay from a single free-text query via xona's x402-paywalled /shop/search endpoint (partner integration). The query parser picks up price ranges, condition, and sort straight from natural language; results come back normalized, deduped, and ranked in one schema. Price scales with the marketplaces searched: ~$0.02 USDC for all three, less for a subset (floor $0.005). Paid through the normal x402 flow, so guardrail caps apply (if your profile restricts allowedHosts, api.xona-agent.com must be on the list):
xpay shop quote "used thinkpad x1 under $600" # free: exact price + parsed intent, no wallet
xpay shop search "used thinkpad x1 under $600" # paid: quotes first, confirms, then searches
xpay shop search "sony wh-1000xm5" --marketplaces amazon,ebay --sort price_asc
shop search runs the free quote automatically before asking for confirmation, and refuses to pay when the parser says the query is not a product search (a paid search for such a query charges but returns zero results).
MCP: xpay_shop_search (paid) / xpay_shop_quote (free preflight: agents should quote first when a query is ambiguous). MCP results are compacted for context (image/position/scoring fields dropped); xpay shop search --json keeps the full payload. Endpoint override: XPAY_SHOP_ENDPOINT.
The same partner also answers "what is this, and where do I buy it" from a photo. Give /shop/lens an image and Google Lens identifies the product and the retailers selling it, normalized into the same schema as /shop/search. Two modes: identify (default, $0.02 USDC) returns the visual matches plus a derived product name; $0.04 for all three marketplaces) additionally runs that name through Google Shopping, Amazon, and eBay for a price comparison.shop (
The lens engine itself only accepts a publicly reachable http(s) URL (SerpAPI fetches the image; data URIs are rejected), so the MCP tool takes the image as exactly one of three inputs: image_url (used as-is), image_path (local file), or image_base64 (raw or data URI). Local files and base64 are first uploaded, free, to xona's public image host (JPEG/PNG/GIF/WebP, type sniffed from magic bytes, 25MB cap) and the hosted URL is echoed back as hosted_image_url for reuse. This is what makes images from chat clients that upload attachments (Hermes and friends) work: bytes in, public URL bridged automatically.
MCP: xpay_shop_lens (paid) / xpay_shop_lens_quote (free preflight: validates an image URL is publicly reachable and reports the exact price, no wallet). Agents should quote first when passing image_url, since the paid door charges even when the URL turns out to be unusable; uploads need no preflight because the hosted URL is always reachable. If the response flags the image as not a product photo, a mode=shop retry will not help.
init configures Solana and Base by default. Add or change via ~/.xpay/<name>/config.json:
{
"version": 1,
"networks": ["solana", "base", "arbitrum", "stable"],
"defaultNetwork": "solana",
"rpcs": {
"solana": "https://your-helius-endpoint",
"base": "https://your-alchemy-endpoint",
"stable": "https://rpc.stable.xyz"
}
}
Public RPCs work for development but rate-limit hard. Production deployments should configure dedicated RPC endpoints.
Stable (chain 988, Tether/Bitfinex's payments L1) is supported as a first-class wallet network. It settles USDT0 (the LayerZero OFT at 0x779Ded0c9e1022225f8E0630b35a9b54bE713736, 6 decimals as an ERC-20), not USDC.
The same derived EVM key covers it, so a Stable signer is registered on every profile whether or not stable is in networks. You get it without re-running xpay init:
xpay balance # includes a stable row: USDT0 + native USDT gas
xpay balance --network stable
xpay discover "image generation" --network stable
xpay transfer 1.5 0xRecipient --network stable # sends USDT0
Notes:
transferWithAuthorization and the facilitator broadcasts, so the wallet needs USDT0 only - no native gas. Direct xpay transfer is broadcast from your wallet, so that path needs a little native USDT for gas.USDT0 / 1, not the USDC default. xpay never hardcodes it: the domain is read from extra on the live 402 challenge, which is the only reliable source (version() and eip712Domain() both revert on this contract).xpay balance lists them separately.eip155:988 resolves to the Stable signer, and use() compares USDT0 balance against the price when several chains are offered.rpcs.stable (default https://rpc.stable.xyz). Explorer: stablescan.xyz.m/44'/501'/0'/0', Phantom-compatible) and EVM (m/44'/60'/0'/0/0, MetaMask-compatible) keypairs. Encrypted at rest with scrypt + AES-256-GCM.Promise.allSettled, so one source failing never kills discovery). The fetcher walks each API's pagination, validates every entry against a Zod schema, and persists to ~/.xpay/cache/ so repeat lookups skip the cold-fetch tax. (Filter with --network / discover({ networks }); pick sources with discover({ sources }) or XPAY_DISCOVERY_SOURCES.)use() and useByUrl() both go: guardrail check → signer.pay(USDC) on the right network → X-Payment header → retry. The signer abstraction means the same code path works for Solana SPL transfers and EVM ERC-20 transfers. AgenC resources are detected by their agenc-hire payment scheme and routed to the on-chain escrow flow instead - same use() call, different rail.v0.2.14 (current):
xpay token find, xpay swap)xpay x user|posts)xpay zauth reposcan)xpay shop search), free quote preflightxpay orders): recurring buys + conditional one-shots, human-approved, idempotent runsxpay trust, trust lines in xpay discover)xpay token rwa): tokenized stocks/ETFs + USDY, swappable via xpay swapxpay sana link) - 8 additional sana_* toolsxpay agenc hire|status)Planned:
bridge, USDC EVM ↔ SVM via CCTP (Circle's native burn/mint)link / unlink, opt-in cloud sync (audit log, dashboard)xpay agenc accept|rate - review AgenC hire results without leaving the CLIMIT - see LICENSE.
Xona Wallet: agent wallet and payment rail for agentic commerce. Multi-network wallet, x402 payments, AgenC marketplace hires, 20k+ services via PayAI and other catalogs
{ "mcpServers": { "xona-labs-xpay": { "command": "npx", "args": [ "-y", "@xona-labs/[email protected]" ] } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
@xona Labs/xpay stdio पर लोकल चलता है।
पिछली जाँच 2026-11-16 को हुई। Xona Wallet: agent wallet and payment rail for agentic commerce. Multi-network wallet, x402 payments, AgenC marketplace hires, 20k+ services via PayAI and other catalogs