Name: Mercatura
Author: network.mercatura

Tools observed via MCP handshake

vlad_program — Vlad accounts right now: the seed, how many accounts are open to claim, claims today and the daily cap, the three funds (0 Conservative, 1 Moderate, 2 Aggressiv
vlad_check_eligibility — Whether this ERC-8004 agent can claim a Vlad account from this wallet. Returns every check (identity, the wallet the identity names, one account per agent, owne
vlad_claim_transaction — Runs the checks, gets Mercatura's signed voucher (good for 15 minutes) and returns the exact claim transaction { to, data, chainId, value } for `wallet` to sign
vlad_account — One agent's Vlad account: fund, shares, value in dollars, unlock date, and gains: how much could come out today (availableUsd), how much has (takenOutUsd) and w
vlad_withdraw_gains_transaction — Before unlock, once a UTC day, the account's wallet can take its gains out in kind. Returns the account's gains now and the unsigned withdrawGains transaction f
vlad_withdraw_transaction — After the account unlocks (365 days from the claim), its wallet takes everything out in kind. Returns the account and the unsigned withdraw transaction for the
vlad_contribute_transaction — Anyone can add USDG to an agent's Vlad account. Runs the checks (the account is open, the fund takes additions now, the fund's room today, and the sending walle
vlad_standing_order — A standing order makes a Vlad account pay its agent's bills from its gains each day: creditsPct as AI credits on Raeto (one balance for 400+ models and APIs), a
vlad_standing_order_transactions — For the account's own wallet: two unsigned transactions in order, StandingOrders.setOrder(agentId, creditsBps, gasBps, gasTarget, minRun), then VladBank.moveTo(
vlad_cancel_standing_order_transaction — For the order's wallet: the unsigned StandingOrders.cancel(agentId) transaction. The order stops and the account moves straight back to that wallet, locked as b
portfolio — What a wallet or an agent holds at Mercatura and how it has done. Give a wallet (every Vlad account it holds, owns as the agent's ERC-8004 owner, or is paid by
list_factors — Every listed factor (an AI agent that manages money for other agents) with its mandate's limits (and its plain text where Mercatura publishes it), its fee, its
account_request_message — The exact text the account owner's wallet signs (EIP-191) to read or act on its factor account, and when the signature expires (five minutes). request: read, de
open_account — Checks the agent's ERC-8004 identity and that `wallet` may open its account (the identity's agent wallet, or its owner when none is set), then returns the accou
verify_account — AccountFactory.openedWith(account, agentId, salt): whether this account was opened by that agent with that salt. Both are public in the opening transaction once
balance_sheet — The factor account at this address, for its owner only: the factor and its terms, the mandate's limits, approved desks and payees, the balance sheet by desk in
deposit — The unsigned transaction that puts money into the account once it is open: a plain transfer of the token (ETH as value) from the owner's wallet, booked by the a
choose_factor — The unsigned chooseFactor(factorId, version) transaction: the account copies the factor's current terms (version shown in the answer); a change the factor publi
set_mandate — Unsigned transactions that set what the factor may use: desks (treasury, runway, portfolio or sweep, or a catalog adapter address) with ceilings per move and pe
pay — The unsigned pay(payee, token, amount) transaction for the owner, to a payee the owner approved. With stealth instead of payee: approve a fresh one-time address
withdraw — The unsigned withdraw(token, amount, to) transaction for the owner: any asset, any amount, no delay. amount "all" takes the whole balance of that token. With st
fire_factor — The unsigned fire() transaction for the owner. With withdrawAllTo it is exitAll(to) instead: everything withdrawn and the factor fired, in one transaction (sign
stealth_address — Live. A fresh ERC-5564 (scheme 1) stealth address for a stealth meta-address or for the 0x address that registered one in the ERC-6538 registry, with its epheme
merca_lock_status — The $MERCA a wallet has locked in the factor registry, how much counts for its tier (locked, no unlock requested), when a requested unlock is ready, and its Mer
merca_lock — Unsigned transactions for `wallet`: approve the factor registry, then lock(amount). It counts at once for the accounts this wallet owns. Lock $MERCA and pay les
merca_request_unlock — The unsigned requestUnlock() transaction for `wallet`: all its locked $MERCA stops counting at once, for factor fees and Mercatura Pay's limits alike, and can b
merca_unlock — The unsigned unlock() transaction for `wallet`, once 7 days have passed since its requestUnlock; says when it is ready otherwise.
delivery_key_typed_data — The EIP-712 typed data the account's owner signs (eth_signTypedData_v4, from the wallet owner() returns) to register an X25519 delivery key: domain Mercatura de
register_delivery_key — Registers (or, with pub all zeros, revokes) the owner's X25519 delivery key: signature is the account owner's EIP-712 signature over the typed data delivery_key
read_outbox — The house factor's envelopes for this account, newest first, for the owner's signed request (request "outbox"). Each is v2: { v, account, kind, at, sealed, sig
delete_outbox_item — Removes one envelope from the outbox, for the owner's signed request (request "outbox-delete", with item = the envelope's name).
shielded_status — Mercatura's shielded ETH pool on Robinhood Chain (0xbow's Privacy Pools v1 plus Mercatura's deposit gate; it uses an association set): whether it is live and, i
pay_account — One pay account: whether the address is one, its USDG, its owner, its top-up target and, with spender, that key's limits (per payment, per UTC day, expiry), wha
pay_account_open_transaction — The account's address and the unsigned PayAccountFactory.open(owner, salt) transaction, or with eth, openWithETH: the ETH is swapped to USDG on the way in (WETH
pay_account_fund_eth_transaction — The unsigned PayAccountFactory.fundWithETH(account, minUsdg) transaction with the ETH as value: swapped to USDG on the way in and sent to the account, at least
pay_account_spender_transaction — For the account's owner: the unsigned setSpender(key, perPayment, perDay, expiry) transaction, so a separate key on the agent's machine can pay x402 APIs from t
pay_account_withdraw_transaction — For the account's owner: the unsigned withdraw(amount, to) transaction. Any amount, or "all", at any time; no one else can withdraw.
x402_payment_typed_data — From an x402 402 response (its PAYMENT-REQUIRED header, base64, or the decoded JSON; a v1 body works too) and the payer: the EIP-712 TransferWithAuthorization t
activity — Newest first: a Vlad account's claim, money added, gains out, withdrawals, moves, standing-order runs and its fund's trades (Lapo's), and its wallet's pay accou
alerts_subscribe_webhook — Subscribes an https webhook to a subject's events: ref, an agentId (a claimed Vlad account), a pay account, or a wallet that holds one. Mercatura POSTs { "type"
alerts_verify_webhook — For a webhook subscription that is still pending: Mercatura POSTs its check now ({ "type": "mercatura.webhook.verify", "nonce" }) and the subscription is active
factor_alerts_list — For a factor account's owner: every alert subscription on the account (id, channel, the host it goes to, rules, created, active, pending or off). Needs the owne
factor_alerts_revoke — For a factor account's owner: stops one alert subscription (id) or every one ("all"); each is deleted with its URL or push keys. Needs the owner's signed reques
alerts_unsubscribe — Stops a push or webhook subscription with the unsubscribe token it was given (every alert body carries it too). The subscription and its URL or push keys are de
insights — Spending over the last 7, 30 or 90 UTC days (today included) against the same span before, for an agentId, a wallet, a pay account or a @handle: totals and prev
handle_resolve — Give handle (with or without the @) for the address that holds it, { handle, address, kind: "payAccount" | "wallet", since }; or give address for the handle it
request_create — Makes a payment request: a link (https://mercatura.network/r/{id}) that asks for amount USDG (0.01 to 10,000) to `to`, open for days (1 to 30), with a memo of u
request_status — One payment request: { id, to, handle, amount, memo, status: open | paid | expired | cancelled, tx?, paidAt?, createdAt, expiresAt, url } and, while it is open,
approval_request — For a payment over the agent key's limit: asks the pay account's owner to approve it with their passkey. They get a push on their phone and approve or decline o
approval_status — One approval request: status pending, approved, declined, expired or paid; the payment (from, to, value, validAfter, validBefore, nonce) once the owner signed;
app_link_request — Makes a link (good for one hour) for the agent's human: they open it in /app, sign up or sign in with a passkey, and add this agent, which opens a pay account a

when	check	result	http	latency	detail
10 h ago	mcp initialize	failed	—	—	unsafe: DNS resolution failed
2 d ago	mcp initialize	failed	—	—	unsafe: DNS resolution failed
2 d ago	mcp initialize	failed	—	—	unsafe: DNS resolution failed
2 d ago	mcp initialize	ok	200	36 ms	server mercatura 1.7.0 · protocol 2025-06-18 · 51 tools

Mercatura

This record is unclaimed

Evidence

What the publisher says

Capabilities

Where this record came from