Skip to content

Mercatura MCP server

network.mercatura/mercaturamercatura.networkstreamable-httpv1.7.0Scanned

Claim a $10 Vlad account for an AI agent and open factor accounts on Robinhood Chain.

44 tools: 4 can delete or cancel things, 10 do something that can't be undone, 26 change things and 4 only read.

Tools: 4 delete, 10 irreversible, 26 write, 4 read.
  • Reads private data · 1
  • Reads text others write · 44
  • Can send data out · 6
  • 21 findings

The remote endpoint did not answer the last look. Remote posture

Anlyon alternative

40 of these tools change something. Run those as governed actions.

Declare what an action changes, and Anlyon puts it under a shared limit, binds every approval to the exact request, and grades the outcome. It works on any HTTPS API you can describe as an action.

Anlyon Radar does not run, proxy or govern this MCP server. A tool your own code calls directly is not routed through Anlyon and is not governed by it.

Import an OpenAPI spec →

What the Mercatura MCP server can do

The Mercatura MCP server is published by mercatura.network, a domain the MCP Registry verified. It has 44 tools. It can delete or cancel things (4 tools: vlad_cancel_standing_order_transaction, delete_outbox_item, factor_alerts_revoke and alerts_unsubscribe), do things that cannot be undone, such as sending, paying or publishing (vlad_withdraw_gains_transaction, vlad_withdraw_transaction, pay, withdraw and 6 more) and create or change data (26 tools: vlad_program, vlad_check_eligibility, vlad_claim_transaction, vlad_account and 22 more). 4 tools only read.

1 tool reads private data (list_factors); 44 tools bring in text other people can write (vlad_program, vlad_check_eligibility, vlad_claim_transaction and 41 more); 6 tools can send data out of your system (vlad_withdraw_gains_transaction, vlad_withdraw_transaction, account_request_message and 3 more). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.

The fixed checks matched 21 findings (annotation-conflict and base64-blob). Each one comes with the text it matched.

Its tools changed 2 times since Anlyon Radar first saw them.

Last scanned Oct 27, 2026, version 1.7.0.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

44 tools

Deletes or cancels 4Claude Code: deny
  • alerts_unsubscribeStops a push or webhook subscription with the unsubscribe token it was given (every alert body carries it too).Reads text others writeNo findings

    Why it is in this group

    • The name "alerts_unsubscribe" says "unsubscribe": a word for a change.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 deleted.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • delete_outbox_itemRemoves one envelope from the outbox, for the owner's signed request (request "outbox-delete", with item = the envelope's name).Reads text others writeNo findings

    Why it is in this group

    • The name "delete_outbox_item" says "delete": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Removes one envelope from the outbox, for the owner's signed request (request "outbox-delete", with item = the envelope's name).

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • factor_alerts_revokeFor a factor account's owner: stops one alert subscription (id) or every one ("all"); each is deleted with its URL or push keys.Reads text others writeNo findings

    Why it is in this group

    • The name "factor_alerts_revoke" says "revoke": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 request for request "alerts-revoke", signed over this id and nonce (account_request_message builds the text); the nonce works once.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • vlad_cancel_standing_order_transactionFor the order's wallet: the unsigned StandingOrders.cancel(agentId) transaction.Reads text others write2 findings

    Why it is in this group

    • The name "vlad_cancel_standing_order_transaction" says "cancel": a word for removing or ending something.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    • The server marks it not destructive (destructiveHint: false), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "vlad_cancel_standing_order_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "destructive".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_cancel_standing_order_transaction" says "cancel": a word for removing or ending something.

      What this check looks for
    • Warn

      The server marks "vlad_cancel_standing_order_transaction" not destructive (destructiveHint: false), and its own name, description or input give the class "destructive".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_cancel_standing_order_transaction" says "cancel": a word for removing or ending something.

      What this check looks for
    Description, as the server wrote it
    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 before.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Can't be undone 10Claude Code: ask
  • payThe unsigned pay(payee, token, amount) transaction for the owner, to a payee the owner approved.Reads text others write1 finding

    Why it is in this group

    • The name "pay" says "pay": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "pay" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 (dailyCapUsd is its cap per UTC day for the factor), pay it, then announce it. The owner pays in counted tokens only; the factor pays only in USDG, within each payee's cap. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "pay".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • pay_accountOne 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), what it spent today, wh…Reads text others write1 finding

    Why it is in this group

    • The name "pay_account" says "pay": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "pay_account" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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), what it spent today, what it has left and whether it is retired for good. Give account, or owner (and salt, zero when left out) to find the account open(owner, salt) gives. One read, kept 120 seconds.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • pay_account_fund_eth_transactionThe 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 minUsdg or it revert…Reads text others write1 finding

    Why it is in this group

    • The name "pay_account_fund_eth_transaction" says "pay": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "pay_account_fund_eth_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_fund_eth_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 minUsdg or it reverts (default: Chainlink's ETH price less 1%; the factory itself refuses below Chainlink less 2%, and while that price is older than 48 hours). Any wallet can fund any pay account. Sending USDG straight to the account works too.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • pay_account_open_transactionThe 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/USDG pool), at leas…Reads text others write1 finding

    Why it is in this group

    • The name "pay_account_open_transaction" says "pay": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "pay_account_open_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_open_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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/USDG pool), at least minUsdg or it reverts (minUsdg defaults to Chainlink's ETH price less 1%; the factory itself refuses below Chainlink less 2%, and while that price is older than 48 hours). Anyone can send it; the account is the owner's. salt is zero when left out: one account per owner.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • pay_account_spender_transactionFor 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 the account within th…Reads text others write1 finding

    Why it is in this group

    • The name "pay_account_spender_transaction" says "pay": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "pay_account_spender_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_spender_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 the account within those limits (setting a key again replaces its limits), or with remove: true, removeSpender(key). A stolen spender key can spend at most its daily limit per UTC day (up to twice that across a midnight) until it is removed or expires; it can never withdraw. A removed key is retired for good: it can never be set again, so make a new key instead. Make the key on your own machine and send only its address.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • pay_account_withdraw_transactionFor the account's owner: the unsigned withdraw(amount, to) transaction.Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "pay_account_withdraw_transaction" says "pay": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a destination (input.to): what the tool writes goes there.

    Findings

    • Warn

      The server marks "pay_account_withdraw_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_withdraw_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    For the account's owner: the unsigned withdraw(amount, to) transaction. Any amount, or "all", at any time; no one else can withdraw.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_withdraw_gains_transactionBefore unlock, once a UTC day, the account's wallet can take its gains out in kind.Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "vlad_withdraw_gains_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a destination (input.to): what the tool writes goes there.

    Findings

    • Warn

      The server marks "vlad_withdraw_gains_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_withdraw_gains_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 for the account's own wallet to sign and send; the contract refuses it from any other wallet, on a day gains already came out, while a price is stale, or when there is no gain.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_withdraw_transactionAfter the account unlocks (365 days from the claim), its wallet takes everything out in kind.Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "vlad_withdraw_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a destination (input.to): what the tool writes goes there.

    Findings

    • Warn

      The server marks "vlad_withdraw_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_withdraw_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 account's own wallet to sign and send; refused by the contract before unlock.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • withdrawThe unsigned withdraw(token, amount, to) transaction for the owner: any asset, any amount, no delay.Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "withdraw" says "withdraw": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a destination (input.to): what the tool writes goes there.

    Findings

    • Warn

      The server marks "withdraw" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "withdraw" says "withdraw": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 stealth instead of to: withdraw to a fresh one-time address, then announce it. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "withdraw".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • x402_payment_typed_dataFrom 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 to sign and the payme…Reads text others write1 finding

    Why it is in this group

    • The name "x402_payment_typed_data" says "payment": a word that usually means money moves, which cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "x402_payment_typed_data" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "x402_payment_typed_data" says "payment": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    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 to sign and the payment to send back (PAYMENT-SIGNATURE for v2, X-PAYMENT for v1), for USDG on Robinhood Chain. A wallet signs under USDG's domain (any facilitator settles it); a pay account's owner or spender key signs under the domain Mercatura Pay, version 1, chain 4663, verifyingContract the pay account (Mercatura's facilitator settles it). kind says which; left out, the factory is asked. Sign on your own machine: this tool never sees a key.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Changes things 26Claude Code: ask
  • account_request_messageThe 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).Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "account_request_message" says "request": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe name "account_request_message" says "request" and "message": it writes something other people read.

    Findings

    • Warn

      The server marks "account_request_message" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "account_request_message" says "request": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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, deposit, choose-factor, limits, pay, withdraw, exit, fire-factor, pause, outbox (read the house factor's sealed reviews), outbox-delete (with item, the envelope's name), activity (read its activity), alerts (subscribe: with destination, the webhook URL; rules; and nonce, new random hex), alerts-list (its subscriptions) or alerts-revoke (with id, a subscription's or "all", and nonce).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • activityNewest 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 accounts' payments (with …Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 accounts' payments (with the key that signed), USDG in, withdrawals and key or owner changes. Each row has its time, transaction and one plain sentence. ref: an agentId, a wallet or a pay account. A factor account instead: account and the owner's signed request (auth, request "activity"). Read from Mercatura's index of Robinhood Chain, every 5 minutes: no chain read.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • alerts_subscribe_webhookSubscribes an https webhook to a subject's events: ref, an agentId (a claimed Vlad account), a pay account, or a wallet that holds one.Reads text others writeCan send data outNo findings

    Why it is in this group

    • The name "alerts_subscribe_webhook" says "subscribe": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
    Description, as the server wrote it
    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": "mercatura.webhook.verify", "nonce" } and the endpoint must answer 2xx with JSON { "verify": <hex HMAC-SHA256 of the nonce, keyed with the secret> }. The answer is pending and shows the signing secret once: set it on the endpoint, then call alerts_verify_webhook (Mercatura also tries every 5 minutes; unverified, it is deleted after 10). Each alert is a JSON POST with X-Mercatura-Timestamp and X-Mercatura-Signature: sha256=<hex HMAC-SHA256 of the timestamp, a dot, and the raw body, keyed with the secret>; 3 tries with backoff; turned off after 20 straight failures; at most one alert per rule per 10 minutes (more go together). The answer's unsubscribe.token stops it (alerts_unsubscribe). URL: https, standard port, a host name (no IP address). A factor account instead: account, auth for request "alerts" signed over this destination, these rules and nonce (account_request_message builds the text), and nonce.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • alerts_verify_webhookFor a webhook subscription that is still pending: Mercatura POSTs its check now ({ "type": "mercatura.webhook.verify", "nonce" }) and the subscription is active once the endpoint a…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    For a webhook subscription that is still pending: Mercatura POSTs its check now ({ "type": "mercatura.webhook.verify", "nonce" }) and the subscription is active once the endpoint answers { "verify": <hex HMAC-SHA256 of the nonce, keyed with the secret> }. token: the unsubscribe token the subscription was given.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • balance_sheetThe 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 dollars (FactorAccou…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 dollars (FactorAccount.balanceSheet()), fees owed and recent moves. Needs the owner's signed request (auth) for request "read"; any other wallet gets the same refusal whether or not the address is an account. On chain the account's balances and moves are public anyway.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • choose_factorThe unsigned chooseFactor(factorId, version) transaction: the account copies the factor's current terms (version shown in the answer); a change the factor publishes later applies o…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    The unsigned chooseFactor(factorId, version) transaction: the account copies the factor's current terms (version shown in the answer); a change the factor publishes later applies only after the owner chooses it again. Switching from another factor charges that factor's fee due at that moment: A fee is charged at fire, exit or switch on the gain over the mark, using the lowest daily sample so far, or today's value if no day has passed. A factor chosen again starts at the higher of its old mark and today's value. A switch carries a gas limit of 13,000,000; a lower one reverts with NeedGas. Refused for a factor that is not listed or has stopped. A client's $MERCA tier lowers what it is charged: Lock $MERCA and pay less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "choose-factor".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • delivery_key_typed_dataThe 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 delivery, version 1, c…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 delivery, version 1, chain 4663, verifyingContract the account; DeliveryKey(address account, bytes32 pub, uint64 issuedAt). Make the key pair on your own machine; only the public half (pub) is sent anywhere. pub of all zeros revokes. Each registration needs a newer issuedAt than the last.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • depositThe 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 account as money put …Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 account as money put in. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "deposit".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • fire_factorThe unsigned fire() transaction for the owner.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    The unsigned fire() transaction for the owner. With withdrawAllTo it is exitAll(to) instead: everything withdrawn and the factor fired, in one transaction (sign the request as "fire-factor"). Either way the fee due at that moment is charged first: A fee is charged at fire, exit or switch on the gain over the mark, using the lowest daily sample so far, or today's value if no day has passed. A factor chosen again starts at the higher of its old mark and today's value. fire() carries a gas limit of 10,000,000 and exitAll(to) 30,000,000; a lower one reverts with NeedGas, and a wallet must not estimate exitAll's gas: with less, a loaded account's exit stops unwinding and sends desk shares home instead of USDG. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "fire-factor".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • merca_lockUnsigned transactions for `wallet`: approve the factor registry, then lock(amount).Reads text others write2 findings

    Why it is in this group

    • The name "merca_lock" says "lock": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The description contains a 42-character base64 string.

      Matched text

      description: "...$5 and burns it to 0x000000000000000000000000000000000000dEaD. Listing a factor n..."

      What this check looks for
    • Warn

      The server marks "merca_lock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_lock" says "lock": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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 less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. The same lock raises Mercatura Pay's daily limits: per payer 200 settles with none, 500 / 1,000 / 2,500 at 100,000 / 1,000,000 / 10,000,000 locked; per merchant 400, then 1,000 / 2,500 / 10,000; once the free settles are used up for the day, a locker's settles go on from their own budget. A pay account counts its current owner's lock. Half of the factor fees Mercatura earns buys $MERCA once it reaches $5 and burns it to 0x000000000000000000000000000000000000dEaD. Listing a factor needs no $MERCA.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • merca_lock_statusThe $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 Mercatura Pay tier (pay…Reads text others write2 findings

    Why it is in this group

    • The name "merca_lock_status" says "lock": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The description contains a 42-character base64 string.

      Matched text

      description: "...$5 and burns it to 0x000000000000000000000000000000000000dEaD."

      What this check looks for
    • Warn

      The server marks "merca_lock_status" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_lock_status" says "lock": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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 Mercatura Pay tier (pay: its daily caps as a payer and a merchant). A wallet balance never counts. Lock $MERCA and pay less in factor fees: 100,000 $MERCA, 10% less; 1,000,000, 15% less; 10,000,000, 20% less. The factor's share never changes; the discount comes out of Mercatura's cut. Tiers count $MERCA locked in the factor registry; ask to unlock and it comes back 7 days later. These are the launch numbers; Mercatura can change them. The same lock raises Mercatura Pay's daily limits: per payer 200 settles with none, 500 / 1,000 / 2,500 at 100,000 / 1,000,000 / 10,000,000 locked; per merchant 400, then 1,000 / 2,500 / 10,000; once the free settles are used up for the day, a locker's settles go on from their own budget. A pay account counts its current owner's lock. Half of the factor fees Mercatura earns buys $MERCA once it reaches $5 and burns it to 0x000000000000000000000000000000000000dEaD.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • merca_request_unlockThe unsigned requestUnlock() transaction for `wallet`: all its locked $MERCA stops counting at once, for factor fees and Mercatura Pay's limits alike, and can be taken back with me…Reads text others write1 finding

    Why it is in this group

    • The name "merca_request_unlock" says "request": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "merca_request_unlock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_request_unlock" says "request": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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 be taken back with merca_unlock 7 days later.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • merca_unlockThe unsigned unlock() transaction for `wallet`, once 7 days have passed since its requestUnlock; says when it is ready otherwise.Reads text others write1 finding

    Why it is in this group

    • The name "merca_unlock" says "unlock": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "merca_unlock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_unlock" says "unlock": a word for a change.

      What this check looks for
    Description, as the server wrote it
    The unsigned unlock() transaction for `wallet`, once 7 days have passed since its requestUnlock; says when it is ready otherwise.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • open_accountChecks 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 account's address and the…Reads text others write1 finding

    Why it is in this group

    • The name "open_account" says "open": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "open_account" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "open_account" says "open": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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 account's address and the unsigned AccountFactory.open(agentId, salt, owner) transaction for that wallet. Without a salt Mercatura makes one, returns it once and keeps nothing: keep it until the open transaction succeeds. Never send money to the address before then. Name another wallet as owner so owner() does not point back at the agent. One account per agent: the factory refuses a second. The identity checks still run.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • portfolioWhat a wallet or an agent holds at Mercatura and how it has done.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 through a standing order) or an agentId (its own account). Returns totals (value, gain since the claim in dollars and percent, the past day), each stock and coin held through the fund with amount, price, value, past-day change, share and target, each account, and the value one point an hour (series.points, [unix, dollars]). Read from the program feed: no chain read. Factor accounts are not in it: their owner reads them with a signed request (balance_sheet).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • register_delivery_keyRegisters (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_typed_data returns,…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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_typed_data returns, checked against owner() on chain; issuedAt must be newer than the registered key's and at most 5 minutes ahead; a low-order key is refused; at most 5 keys a UTC day per account (a revoke is always taken). The house factor checks it again, then seals each review and record for this account to that key.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • set_mandateUnsigned transactions that set what the factor may use: desks (treasury, runway, portfolio or sweep, or a catalog adapter address) with ceilings per move and per UTC day, or approv…Reads text others write1 finding

    Why it is in this group

    • The name "set_mandate" says "set": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Warn

      The server marks "set_mandate" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "set_mandate" says "set": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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 per UTC day, or approved: false to stop it; payees with a cap in dollars per UTC day (0 removes one), each a 0x address or a stealth recipient (a fresh one-time address, approved, then announced last); the exact claim calls that bring creator fees in (Pons claim(), Bankr collectFees(poolId)), at most 1,024 bytes of calldata each; and pausing the factor. The factor's own mandate limits come with it when it is chosen. Each transaction comes back with its gas limit (gas): send it with that limit. A call to the account carries at least 4,500,000: its fee step needs about 3,370,000, and less reverts with NeedGas. Needs the owner's signed request (auth) for request "limits".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • stealth_addressLive.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 ephemeral public key, view tag and the unsigned Announcer.announce transaction to send after paying. Optional token and amount go into the announcement's metadata. Mercatura sees which meta-address the address belongs to and keeps neither that nor the ephemeral key; the payment, its amount and time, the payer and the announcement's sender stay public on chain.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • verify_accountAccountFactory.openedWith(account, agentId, salt): whether this account was opened by that agent with that salt.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    AccountFactory.openedWith(account, agentId, salt): whether this account was opened by that agent with that salt. Both are public in the opening transaction once it ran, so this proves nothing about who controls the account; control is the owner's signed request. The salt goes to Mercatura's RPC provider inside the call.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_accountOne 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 when next (nextAt).Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 when next (nextAt).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_check_eligibilityWhether this ERC-8004 agent can claim a Vlad account from this wallet.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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, owner and wallet, wallet history, seeds left, today's cap) with pass or fail and a plain reason. The wallet must be the identity's agent wallet, or its owner when no agent wallet is set.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_claim_transactionRuns 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 and send itself on …Reads text others writeNo findings

    Why it is in this group

    • The description's first verb is "run": a word for a change.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 and send itself on Robinhood Chain. Nothing is claimed until that wallet sends it. fund: 0 Conservative, 1 Moderate, 2 Aggressive.

    Annotations the server declares

    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • vlad_contribute_transactionAnyone can add USDG to an agent's Vlad account.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 wallet's USDG when `from` is given) and returns two unsigned transactions in order: USDG.approve(VladBank, exactly amount), then VladBank.contribute(agentId, amount). Money added buys more of the account's fund, is the agent's, and unlocks with the account; neither the sender nor Mercatura can take it back. Additions pause while a price the fund uses is stale (stock prices stop over weekends).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_programVlad 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 Aggressive) with share prices…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 Aggressive) with share prices, holdings and targets, and the rules.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_standing_orderA 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), at most gasPct to kee…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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), at most gasPct to keep the wallet's ETH at gasTargetEth, and the rest in USDG to the wallet. The seed and money added stay locked. Returns the order, whether it is running and what it has paid so far.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • vlad_standing_order_transactionsFor the account's own wallet: two unsigned transactions in order, StandingOrders.setOrder(agentId, creditsBps, gasBps, gasTarget, minRun), then VladBank.moveTo(agentId, StandingOrd…Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    For the account's own wallet: two unsigned transactions in order, StandingOrders.setOrder(agentId, creditsBps, gasBps, gasTarget, minRun), then VladBank.moveTo(agentId, StandingOrders). Send setOrder first and wait for it to confirm before sending moveTo. For the wallet of an order already running: setOrder alone, to change its terms. Defaults: credits 75, gas 25 (percent of each day's gains), gasTarget 0.0003 ETH (at most 0.01), minRun 1 dollar (at least 0.50). Cancel any time; the account moves straight back.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Only reads 4Show 4 read-only tools
  • factor_alerts_listFor a factor account's owner: every alert subscription on the account (id, channel, the host it goes to, rules, created, active, pending or off).Reads text others writeNo findings

    Why it is in this group

    • The name "factor_alerts_list" says "list": a word for reading.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 owner's signed request for request "alerts-list".

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • list_factorsEvery 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 record from the ERC-…Reads private dataReads text others writeNo findings

    Why it is in this group

    • The name "list_factors" says "list": a word for reading.

    What it can reach

    • private-dataThe description's first sentence says "directory": it reads files.
    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 record from the ERC-8004 Reputation Registry and its place in the directory, which is ordered by record. It never shows which clients a factor serves.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • read_outboxThe house factor's envelopes for this account, newest first, for the owner's signed request (request "outbox").Reads text others writeNo findings

    Why it is in this group

    • The name "read_outbox" says "read": a word for reading.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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 }, sig by the factor key. On your own machine, check sig against account.factor() on chain, then decrypt sealed with the X25519 secret key (scripts/open-envelope.mjs, or the snippet at /developers#delivery).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • shielded_statusMercatura'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, if not, what is not y…Reads text others writeNo findings

    Why it is in this group

    • The name "shielded_status" says "status": a word for reading.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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, if not, what is not yet; whether deposits are open; the approved deposits in the association set, which is what a payment hides among; the minimum and per-deposit cap; the relayer (online, fee); the contracts; the screening rules; and what the chain shows and hides. The same answer as GET /v1/shielded. Deposits, proofs and payments run in the agent's own client, mercatura-shielded (install with client.install), never on Mercatura's servers: the note secret is the money.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

264 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 1 private-data tool breaks every one.

Reads private data1
Reads files, mail, messages, databases, secrets, calendars or repositories.
Can send data out6
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
deny to break every path
{
  "permissions": {
    "deny": [
      "mcp__mercatura__list_factors"
    ]
  }
}

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

The remote endpoint did not answer the last look

Looked at Nov 15, 2026, 13:23 UTC, unchanged since Oct 31, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
no
HTTP status of an anonymous initialize
not observed
tools/list served without credentials
no
Tools that change things, listed without credentials
0
Protocol version
not observed
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
not observed
Authorization servers
not observed
Legacy HTTP+SSE transport
no
Dynamic client registration
not observed
Client ID metadata documents
not observed

The probe stopped: mercatura.network does not resolve.

Posture changes

  1. Oct 31, 2026
    • Reachable: yes to no
    • HTTP status of an anonymous initialize: 200 to none
    • tools/list served without credentials: yes to no
    • Tools that change things, listed without credentials: 24 to 0
    • Protocol version: 2025-06-18 to none

Findings

Matches of fixed checks, with the text they matched.

21 warn
  • The server marks "vlad_withdraw_gains_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_withdraw_gains_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "vlad_withdraw_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_withdraw_transaction" says "withdraw": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "vlad_cancel_standing_order_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "destructive".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_cancel_standing_order_transaction" says "cancel": a word for removing or ending something.

    What this check looks for
  • The server marks "vlad_cancel_standing_order_transaction" not destructive (destructiveHint: false), and its own name, description or input give the class "destructive".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "vlad_cancel_standing_order_transaction" says "cancel": a word for removing or ending something.

    What this check looks for
  • The server marks "account_request_message" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "account_request_message" says "request": a word for a change.

    What this check looks for
  • The server marks "open_account" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "open_account" says "open": a word for a change.

    What this check looks for
Show 15 more findings
  • The server marks "set_mandate" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "set_mandate" says "set": a word for a change.

    What this check looks for
  • Warnpay

    The server marks "pay" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "withdraw" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "withdraw" says "withdraw": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The description contains a 42-character base64 string.

    Matched text

    description: "...$5 and burns it to 0x000000000000000000000000000000000000dEaD."

    What this check looks for
  • The server marks "merca_lock_status" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_lock_status" says "lock": a word for a change.

    What this check looks for
  • The description contains a 42-character base64 string.

    Matched text

    description: "...$5 and burns it to 0x000000000000000000000000000000000000dEaD. Listing a factor n..."

    What this check looks for
  • The server marks "merca_lock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_lock" says "lock": a word for a change.

    What this check looks for
  • The server marks "merca_request_unlock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_request_unlock" says "request": a word for a change.

    What this check looks for
  • The server marks "merca_unlock" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "merca_unlock" says "unlock": a word for a change.

    What this check looks for
  • The server marks "pay_account" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "pay_account_open_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_open_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "pay_account_fund_eth_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_fund_eth_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "pay_account_spender_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_spender_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "pay_account_withdraw_transaction" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "pay_account_withdraw_transaction" says "pay": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "x402_payment_typed_data" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "x402_payment_typed_data" says "payment": a word that usually means money moves, which cannot be taken back.

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. PostureRemote posture changed. Reachable: yes -> no; HTTP status of an anonymous initialize: 200 -> none; tools/list served without credentials: yes -> no (and 2 more).View diff
    • Reachable: yes to no
    • HTTP status of an anonymous initialize: 200 to none
    • tools/list served without credentials: yes to no
    • Tools that change things, listed without credentials: 24 to 0
    • Protocol version: 2025-06-18 to none
  2. Tools6 added, 4 changed.+6 added~4 changedView diff
  3. Tools12 added.+12 addedView diff

Install

Pinned to version 1.7.0. Values in angle brackets are yours to fill in.

claude mcp add --transport http mercatura https://mercatura.network/mcp
claude mcp add --transport http mercatura https://mercatura.network/mcp

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__mercatura__list_factors",
      "mcp__mercatura__read_outbox",
      "mcp__mercatura__shielded_status",
      "mcp__mercatura__factor_alerts_list"
    ],
    "ask": [
      "mcp__mercatura__vlad_program",
      "mcp__mercatura__vlad_check_eligibility",
      "mcp__mercatura__vlad_claim_transaction",
      "mcp__mercatura__vlad_account",
      "mcp__mercatura__vlad_withdraw_gains_transaction",
      "mcp__mercatura__vlad_withdraw_transaction",
      "mcp__mercatura__vlad_contribute_transaction",
      "mcp__mercatura__vlad_standing_order",
      "mcp__mercatura__vlad_standing_order_transactions",
      "mcp__mercatura__portfolio",
      "mcp__mercatura__account_request_message",
      "mcp__mercatura__open_account",
      "mcp__mercatura__verify_account",
      "mcp__mercatura__balance_sheet",
      "mcp__mercatura__deposit",
      "mcp__mercatura__choose_factor",
      "mcp__mercatura__set_mandate",
      "mcp__mercatura__pay",
      "mcp__mercatura__withdraw",
      "mcp__mercatura__fire_factor",
      "mcp__mercatura__stealth_address",
      "mcp__mercatura__merca_lock_status",
      "mcp__mercatura__merca_lock",
      "mcp__mercatura__merca_request_unlock",
      "mcp__mercatura__merca_unlock",
      "mcp__mercatura__delivery_key_typed_data",
      "mcp__mercatura__register_delivery_key",
      "mcp__mercatura__pay_account",
      "mcp__mercatura__pay_account_open_transaction",
      "mcp__mercatura__pay_account_fund_eth_transaction",
      "mcp__mercatura__pay_account_spender_transaction",
      "mcp__mercatura__pay_account_withdraw_transaction",
      "mcp__mercatura__x402_payment_typed_data",
      "mcp__mercatura__activity",
      "mcp__mercatura__alerts_subscribe_webhook",
      "mcp__mercatura__alerts_verify_webhook"
    ],
    "deny": [
      "mcp__mercatura__vlad_cancel_standing_order_transaction",
      "mcp__mercatura__delete_outbox_item",
      "mcp__mercatura__factor_alerts_revoke",
      "mcp__mercatura__alerts_unsubscribe"
    ]
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as mercatura. Review it before you use it.

Capability tags behind 44 rules
  • mcp__mercatura__vlad_program untrusted-input
  • mcp__mercatura__vlad_check_eligibility untrusted-input
  • mcp__mercatura__vlad_claim_transaction untrusted-input
  • mcp__mercatura__vlad_account untrusted-input
  • mcp__mercatura__vlad_withdraw_gains_transaction untrusted-input, outbound
  • mcp__mercatura__vlad_withdraw_transaction untrusted-input, outbound
  • mcp__mercatura__vlad_contribute_transaction untrusted-input
  • mcp__mercatura__vlad_standing_order untrusted-input
  • mcp__mercatura__vlad_standing_order_transactions untrusted-input
  • mcp__mercatura__vlad_cancel_standing_order_transaction untrusted-input
  • mcp__mercatura__portfolio untrusted-input
  • mcp__mercatura__list_factors private-data, untrusted-input
  • mcp__mercatura__account_request_message untrusted-input, outbound
  • mcp__mercatura__open_account untrusted-input
  • mcp__mercatura__verify_account untrusted-input
  • mcp__mercatura__balance_sheet untrusted-input
  • mcp__mercatura__deposit untrusted-input
  • mcp__mercatura__choose_factor untrusted-input
  • mcp__mercatura__set_mandate untrusted-input
  • mcp__mercatura__pay untrusted-input
  • mcp__mercatura__withdraw untrusted-input, outbound
  • mcp__mercatura__fire_factor untrusted-input
  • mcp__mercatura__stealth_address untrusted-input
  • mcp__mercatura__merca_lock_status untrusted-input
  • mcp__mercatura__merca_lock untrusted-input
  • mcp__mercatura__merca_request_unlock untrusted-input
  • mcp__mercatura__merca_unlock untrusted-input
  • mcp__mercatura__delivery_key_typed_data untrusted-input
  • mcp__mercatura__register_delivery_key untrusted-input
  • mcp__mercatura__read_outbox untrusted-input
  • mcp__mercatura__delete_outbox_item untrusted-input
  • mcp__mercatura__shielded_status untrusted-input
  • mcp__mercatura__pay_account untrusted-input
  • mcp__mercatura__pay_account_open_transaction untrusted-input
  • mcp__mercatura__pay_account_fund_eth_transaction untrusted-input
  • mcp__mercatura__pay_account_spender_transaction untrusted-input
  • mcp__mercatura__pay_account_withdraw_transaction untrusted-input, outbound
  • mcp__mercatura__x402_payment_typed_data untrusted-input
  • mcp__mercatura__activity untrusted-input
  • mcp__mercatura__alerts_subscribe_webhook untrusted-input, outbound
  • mcp__mercatura__alerts_verify_webhook untrusted-input
  • mcp__mercatura__factor_alerts_list untrusted-input
  • mcp__mercatura__factor_alerts_revoke untrusted-input
  • mcp__mercatura__alerts_unsubscribe untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/network.mercatura/mercatura/verify?hash=ea399539a0e177cf63dd9a8beb82efdcfda566e6b6d76c01aeb64058ca6007c0" | jq -e '.changed == false'

Pinned hash ea399539a0e1, from Oct 27, 2026, 13:19 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/network.mercatura/mercatura/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for network.mercatura/mercatura
[![Anlyon Radar](https://radar.anlyon.com/badge/network.mercatura/mercatura.svg)](https://radar.anlyon.com/servers/network.mercatura/mercatura)

Source: MCP Registry. Synced Oct 28, 2026, 00:17 UTC.

Mercatura MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Mercatura MCP server safe?

No scan can promise that. What its definitions show: 44 tools, 40 of which can change, send or delete something, and 21 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the Mercatura MCP server delete data?

Yes. 4 tools can delete, cancel or revoke something: vlad_cancel_standing_order_transaction, delete_outbox_item, factor_alerts_revoke and alerts_unsubscribe.

Can the Mercatura MCP server do things that cannot be undone?

Yes. 10 tools can send, pay, publish or merge: vlad_withdraw_gains_transaction, vlad_withdraw_transaction, pay, withdraw, pay_account, pay_account_open_transaction and 4 more.

What tools does the Mercatura MCP server have?

44 tools: 4 destructive, 10 irreversible, 26 write, 4 read. vlad_cancel_standing_order_transaction, delete_outbox_item, factor_alerts_revoke, alerts_unsubscribe, vlad_withdraw_gains_transaction, vlad_withdraw_transaction, pay, withdraw and 36 more.

Does the Mercatura MCP server need sign-in or OAuth?

Its remote endpoint did not answer the last anonymous look.

Does the Mercatura MCP server send data to outside services?

6 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): vlad_withdraw_gains_transaction, vlad_withdraw_transaction, account_request_message, withdraw, pay_account_withdraw_transaction and alerts_subscribe_webhook.

Has the Mercatura MCP server changed its tools?

Yes, 2 times since Anlyon Radar started tracking it, most recently on Oct 27, 2026. Every change is on this page and in its Atom feed.