Skip to content

Vurto Swap MCP server

io.github.cryptoconspiracy/vurto-swapcryptoconspiracystreamable-httpv1.0.0Scanned

Token swaps at the best net price on 9 EVM chains and Solana. No API key, non-custodial.

32 tools: 12 do something that can't be undone, 15 change things and 5 only read.

Tools: 0 delete, 12 irreversible, 15 write, 5 read.
  • Reads private data · 0
  • Reads text others write · 25
  • Can send data out · 3
  • 9 findings

Tools listed without sign-in. Remote posture

With Anlyon

12 tools here do something that can't be undone. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Vurto Swap MCP server can do

The Vurto Swap MCP server is published by the GitHub account cryptoconspiracy. It has 32 tools. It can do things that cannot be undone, such as sending, paying or publishing (prepare_signing, invoice_create, invoice_analysis_pay, invoice_report_analysis_payment and 8 more) and create or change data (15 tools: swap_build, double_build, nn_quote, nn_build and 11 more), but cannot delete data. 5 tools only read.

25 tools bring in text other people can write (swap_quote, swap_build, double_quote and 22 more); 3 tools can send data out of your system (invoice_create, payout_batch and payout_reuse).

The fixed checks matched 9 findings (credentials-mention, annotation-conflict and long-description). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 2 times since Anlyon Radar first saw them.

Last scanned Nov 17, 2026, version 1.0.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.

32 tools

Can't be undone 12Claude Code: ask
  • check_chargeBuilds the USDC transfer of the Check price for the networks chosen (networks, from check_info checkNetworks: perNetwork each, never above maximum) from payer to the analysis fee w…Reads text others writeNo findings

    Why it is in this group

    • The name "check_charge" says "charge": a word that usually means money moves, which cannot be taken back.

    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
    Builds the USDC transfer of the Check price for the networks chosen (networks, from check_info checkNetworks: perNetwork each, never above maximum) from payer to the analysis fee wallet on chainId (any network of check_info networks), for the payer to sign. The credit is bound to those networks. Needs buyProof, the purchase proof of THIS payer from check_buy_proof (the payer signed and passed the free screening); without it, or with another wallet's, check_buy_proof_required (401). The server also measures the sender on-chain. Returns { check { id, status awaiting_payment, amount, amountRaw, token, feeWallet }, transaction, plan (buildId check-<id>, steps on EVM or transaction on Solana), report }. check.id (CHK-...) is the capability of this Check: whoever holds it reports the payment, analyses and reads the result, so keep it private and keep it to come back to the result. Each call makes a NEW Check, good for 30 minutes (expiresAt): a transaction mined after that is credited by the price of now on the networks it covers (check_report_payment). Pass checkId of one still awaiting payment and in its time to rebuild its transfer (the Solana one expires in about a minute). Sign the transaction exactly as returned: it carries the mark of THIS Check (16 bytes after the transfer arguments on EVM, a memo on Solana). A transfer you build yourself is refused with analysis_payment_rejected reason charge_not_tied after the money left: do not pay again, prove the wallet with destination_challenge (receiver = details.feeWallet, chargeId = the check id, chargeTxHash = that hash) and destination_authorize, then report the same hash again. Refusals: analysis_tool_unavailable (503, a tool is down: nothing is built), check_credit_limit (409), payer_blocked (403), check_network_unsupported (400), check_networks_required (400), check_already_paid (409, checkId of a paid Check), check_charge_expired (409), check_unavailable (503).

    Annotations the server declares

    • title: Check: build the payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • check_report_paymentHand the Check payment to the server once it is mined, by the Check id.Reads text others writeNo findings

    Why it is in this group

    • The name "check_report_payment" says "payment": a word that usually means money moves, which cannot be taken back.

    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
    Hand the Check payment to the server once it is mined, by the Check id. The server reads it on-chain (the payer the charge names signed it, the network USDC reached the fee wallet, at least the price, after the charge, the mark) and reserves the hash for this Check only. 201 with check.status paid: the credit exists. analysis_payment_pending (409): not mined yet, call again in a few seconds. analysis_payment_rejected (400, details.reason): this transaction does not pay this Check. tx_already_used (409): the hash already paid something else. check_not_found (404): no Check has this id. Mined after the charge's 30 minutes it still credits by the price of now on the networks it covers (lateCharge true, check.paidNetworks may be fewer); check_charge_expired (409) only when it covers none. check_credit_limit (409) and payer_blocked (403) are checked again here; nothing is reserved, so the same hash reported later still counts. Repeating the same hash is safe; never pay again.

    Annotations the server declares

    • title: Check: report the payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • invoice_analysis_payDo not use it on an invoice whose split.rule is "brackets" (created since 10/11/2026): its fee is inside the payment and already pays the analysis of both wallets, and the call is …Reads text others write1 finding

    Why it is in this group

    • The name "invoice_analysis_pay" says "pay": a word that usually means money moves, which cannot be taken back.

    What it can reach

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

    Findings

    • Info

      The description is 5,700 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...s.to) and invoiceId = this invoice. On EVM the payer pays with the USDC transfer."

      What this check looks for
    Description, as the server wrote it
    Do not use it on an invoice whose split.rule is "brackets" (created since 10/11/2026): its fee is inside the payment and already pays the analysis of both wallets, and the call is refused with analysis_included_in_fee (409). Without checks: the charge of the invoice creator, for an older invoice with payerChecks or paid checks whose analysis.status is awaiting_payment (see invoice_get). Builds ONE USDC transfer of analysis.amount (the price written when that invoice was created: 0.10 Scorechain, 0.40 Merkle Science, 0.50 both) to the Vurto fee wallet (analysis.to), signed by the invoice creator. Sign the charge transaction exactly as returned: it carries the mark that ties the payment to this charge (16 bytes after the transfer arguments on EVM, a memo on Solana). A transfer you build yourself is refused with analysis_payment_rejected, reason charge_not_tied, after the money has left; do not pay again, prove the wallet (destination_challenge with wallet = payer, receiver = details.feeWallet, chargeId = this charge and chargeTxHash = that hash, then destination_authorize) and report the same hash again. Nothing is signed or sent here. The free screening runs first on the receiving wallet and on the creator: a rejected wallet gets screening_blocked (403) and nothing is built; a screening that cannot be read gets screening_unavailable (503). payer must be the creator (the receiving wallet when the invoice was created without a session, which is always the case over MCP); any other wallet gets not_invoice_creator (403) before anything is built. plan has the same shape as invoice_pay (prepare_signing; on Solana POST the signed transaction to /v1/svm/execute), then call invoice_report_analysis_payment with the hash or signature. Paying it from another token is a swap built over the HTTP API (POST /v1/swap on EVM, POST /v1/svm/swap on Solana) from the creator wallet with tokenOut = analysis.token, receiver = analysis.to and invoiceId = this invoice, sized so the guaranteed minimum covers analysis.amountRaw; report its hash or signature to invoice_report_analysis_payment. On EVM only a swap built that way counts (the transaction must match that build); on Solana the Vurto fee wallet must be the only wallet whose USDC rises in it, and it must be the transaction we built, which carries the mark. The minimum must stay between the charge and 10% above it (charge_swap_below_amount, charge_swap_above_amount). A swap that only pays a fee to the same wallet does not count. Errors: no_paid_check, analysis_already_paid, analysis_included_in_fee, invoice_already_paid, not_invoice_creator, screening_blocked, screening_unavailable. Invoices of the new model (Solana, and EVM networks with a split contract): this is how the PAYER buys the paid analysis of the RECEIVING wallet, with their own money, before paying. Pass payer = the paying wallet and checks (["merkle-science"], ["scorechain"] or both). Since 11/11/2026 the charge is the bracket fee of the invoice amount (https://docs.vurto.cc/fees), the same with one tool or two, in the network USDC: invoice_get receiverAnalysisFee gives it before you build ({available: true, amount} in dollars) or says the amount is below the minimum ({available: false, minimum}). Below the minimum the call is refused with amount_below_analysis_minimum (400, details.minimum), and on an invoice in a token that is not a dollar stablecoin with stablecoin_required (400). Adding a tool to an analysis already paid and fresh is a new purchase at the same fee. A tool that already ran on that wallet for this payer up to 30 days ago, with no movement measured on the wallet since (on EVM: the same nonce, native balance and balance of every dollar stablecoin of the network, and no contract code; on Solana: no new confirmed signature and the same SOL and associated dollar stablecoin accounts; a read that fails, or any other token or NFT, is not seen, and then the provider is called), comes from the history instead of the provider; each paid tool of the report carries analyzedAt, the day it ran. A new purchase needs no wallet proof, the payment itself proves it; giving it up and changing the tools of an existing charge do (destination_challenge/destination_authorize for this invoice's receiver; without it payer_signature_required, 401). The free screening of both wallets must pass (screening_blocked 403). It returns receiverAnalysis {status: awaiting_payment, amount, to} and the USDC transfer to sign; report it with invoice_report_analysis_payment (txHash and payer). The fee follows the invoice amount, never the number of tools, and the analysis never goes inside the payment. A charge opened before 11/11/2026 and not paid is rewritten with the fee the next time it is built, and reporting a hash on it pays the recorded value only when the network mined it before this deploy; otherwise the charge is rewritten and the answer is analysis_charge_replaced (409): build and sign again. There is no free reuse: every purchase pays the fee. analysis_tool_unavailable (503) when the tool is not answering: nothing is charged. An open, unpaid analysis does not hold invoice_pay, because anyone can open one naming a wallet: pay and report it BEFORE invoice_pay if you want its verdict to count. A paid one goes stale when the receiving wallet moves, and then invoice_pay refuses with receiver_analysis_unpaid (409) until it is redone. checks: [] gives it up. The result comes back without the receiving wallet. Paying it from another token exists on Solana only: POST /v1/svm/swap from the payer with receiver = the fee wallet (receiverAnalysis.to) and invoiceId = this invoice. On EVM the payer pays with the USDC transfer.

    Annotations the server declares

    • title: Build the paid-analysis payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • invoice_createCreate a payment request: who receives, which token, how much, on which network.Reads text others writeCan send data outNo findings

    Why it is in this group

    • The name "invoice_create" says "create": a word for a change.
    • The input addresses people (input.recipient): what it sends cannot be taken back.

    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.recipient): what the tool writes goes there.
    Description, as the server wrote it
    Create a payment request: who receives, which token, how much, on which network. Returns invoice.id, invoice.label (INV-XXXX-XXXX, what people copy), invoice.url (share this, after paying the analysis charge if the invoice has one; it previews with the QR on WhatsApp and Telegram) and invoice.qr (PNG). No signature or API key needed. New invoices only receive VERIFIED dollar stablecoins on the network allowlist, even without paid analysis. A new invoice without payerChecks carries no fee; with payerChecks, the analysis fee of both wallets is deducted from the amount through the split (see payerChecks). Previously created invoices keep their terms. Tokens resolve by address or symbol — an unverified token is refused because a cloned "USDC" with its own pool would let the creator sell a fake at any price. The payer can pay with ANY token on that network. Paid checks in checks are closed for new invoices (paid_check_moved): use payerChecks. the free screening of the receiving wallet must pass for the invoice to be created (receiver_blocked 403, screening_unavailable 503), and payerChecks adds the paid analysis of both wallets, paid by the fee deducted from the amount.

    Annotations the server declares

    • title: Create an invoice
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • invoice_payBuild the plan to pay an invoice from payer, with the token payer holds (default: the invoice token).Reads text others write1 finding

    Why it is in this group

    • The name "invoice_pay" says "pay": a word that usually means money moves, which cannot be taken back.

    What it can reach

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

    Findings

    • Info

      The description is 5,693 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...available (503) means the screening could not finish, try again in a few seconds."

      What this check looks for
    Description, as the server wrote it
    Build the plan to pay an invoice from payer, with the token payer holds (default: the invoice token). Nothing is signed or sent here. Both wallets are screened first (payer_blocked, receiver_blocked); when the invoice has checks ["scorechain"] (see invoice_get), the creator chose and paid the Scorechain sanctions API, so this call sends the payer wallet and the receiver wallet to Scorechain, a third party (an invoice created before 22/10/2026 with the then-free Scorechain keeps running it without a charge). method "transfer": same token, a direct transfer built from the stored invoice (no fee, no gain; the receiver sees the payer as sender). method "swap": another token; amountIn is computed so the GUARANTEED minimum output covers the requested amount, the route is always the one with GAIN when there is one, and the output goes straight to the receiver (the transaction is public and signed by the payer, so the receiver can see the paying wallet on-chain). Any surplus over the requested amount goes to the receiver. plan has the same shape as a swap_build plan: on EVM sign steps[] in order with prepare_signing (approve steps first, then the transaction); on Solana pass {transaction, executionRef} to prepare_signing and POST the signed transaction to /v1/svm/execute. If simulation.status is approval_required, send the approve and call invoice_pay again. When the invoice has paid checks, the creator must have paid the analysis first (analysis_unpaid, 409). With "merkle-science" this call then sends the payer wallet and the receiver wallet to Didit/Merkle Science, and a HIGH or CRITICAL risk (score 70 or more) refuses with payer_blocked or receiver_blocked; the detail shows in invoice_get analysis.report. At most 3 different payer wallets are analysed per invoice by each paid check; a 4th gets analysis_attempts_exceeded (429). Since 23/10/2026 the payer proves the wallet BEFORE the paid analysis runs on it: over MCP that proof is the destination authorization signed by the payer for this invoice's receiver (destination_challenge with wallet = payer, receiver = the invoice receiver, chainId of the invoice, sign the message, then destination_authorize). Without it this call returns payer_signature_required (401) and no analysis slot is spent. Invoices with payerChecks and split.rule "brackets" (since 10/11/2026): nothing is paid first; the paid analysis runs HERE on BOTH wallets, the payer and the receiver, after the free screening, and the plan is the split that delivers split.receiverAmount to the receiver and split.fee to the Vurto fee wallet. A Vurto Dead Alive donation (invoice_get analysisOf "payer") takes 10% of the whole amount as split.fee, never below 0.20 USD (since 12/11/2026, https://docs.vurto.cc/fees); before signing, split.fee must be at most the larger of 10% of the amount and 0.20 USD on a donation, and of 5% and 0.20 USD on every other invoice. Older invoices with payerChecks: the creator pays the analysis first (analysis_unpaid, 409), and it runs HERE, on the payer wallet, after its free screening passes; no field switches it off. The payer proves the wallet first (destination_challenge/destination_authorize; payer_signature_required 401). Up to 2 different payer wallets run here; after that the plan comes out with warning, and the analysis runs on the report of a confirmed payment of the whole amount, with the result going to the creator. A transaction that reaches the receiver settles the invoice: the analysis refuses nothing after the money has arrived. analysis_tool_unavailable (503) means try again in a few minutes. The plan delivers the whole amount to the receiver. An invoice that carries split keeps it (see invoice_get split): method "transfer" is then ONE payment transaction (on EVM, sign the exact approve step first, then VurtoInvoiceSplit.pay) with split.receiverAmount to the receiver and split.fee to the Vurto fee wallet, and only that transaction settles it; analysis_offer_suspended (403) applies only to those. With another token, method "swap_then_transfer": plan is a swap into the PAYER's own wallet and next is this same call again, to build the split; on Solana method "swap" does both in one transaction. A receiver analysis (invoice_analysis_pay) only counts here if it was paid and reported first: open and unpaid, it does not hold this call, and the answer carries warning and receiverAnalysis. Paid and stale gets receiver_analysis_unpaid (409), and a rejected receiver gets receiver_blocked. With method "swap", pass invoiceId to prepare_signing so it points to the invoice report. Sign the transaction as returned: it is tied to this invoice and payer, so another invoice to the same recipient cannot claim it (tx_for_another_payment). A transfer built by hand, a native transfer and a ready-made route of a provider are not, and the first report the network confirms wins. If a transaction of yours ends as tx_for_another_payment, prove the wallet (destination_challenge with chargeId = the invoice id and chargeTxHash = the hash, then destination_authorize) and report it again. Then call invoice_report_payment with the hash (EVM) or signature (Solana). Errors: price_moved (the minimum fell below the request between quote and build — call again), no_route, native_sol_only (an invoice in SOL can only be paid in SOL), invoice_already_paid, private_invoice_paused (a private invoice created before 14/10/2026, paused until the Vurto Private Contract exists). Both wallets are screened before the plan is built: the paying one (payer_blocked) and the receiving one (receiver_blocked). screening_unavailable (503) means the screening could not finish, try again in a few seconds.

    Annotations the server declares

    • title: Build an invoice payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • invoice_report_analysis_paymentHand the analysis payment transaction to the server once it is mined.Reads text others writeNo findings

    Why it is in this group

    • The name "invoice_report_analysis_payment" says "payment": a word that usually means money moves, which cannot be taken back.

    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
    Hand the analysis payment transaction to the server once it is mined. The server reads it on-chain: a direct USDC transfer (the USDC of the invoice network) from the invoice creator to the Vurto fee wallet, of at least analysis.amount, newer than the invoice, never used for another analysis or invoice. screening_blocked (403): the free screening rejects the receiving wallet or the creator, and the payment is not registered. analysis_payment_pending (409): not mined yet, call again in a few seconds. analysis_payment_rejected (400) with details.reason (charge_not_tied, wrong_token, wrong_destination, amount_too_low, sender_not_creator, not_a_transfer, tx_reverted, tx_before_invoice): that transaction does not pay this analysis. charge_not_tied means it is not the transaction we built: do not pay again, prove the wallet (destination_challenge with receiver = details.feeWallet, chargeId = this invoice and chargeTxHash = that hash, then destination_authorize) and report the same hash again. Repeating a hash already recorded returns the status, and the stored result only with the receipt the first record returned (receiverAnalysis.receipt, sent back as receipt) or a proven wallet. tx_already_used (409): the hash already paid something else. Once paid, analysis.status is paid and the invoice can be paid. When the payer bought the analysis of the receiving wallet, pass payer too (the charge of the creator needs only txHash): the transaction must be signed by that payer and only the fee wallet may gain USDC in it (the split payment of an invoice never pays it, usdc_to_other_wallet); once paid the receiver analysis runs right away and receiverAnalysis.result comes back (verdict and the paid tools, never the receiving wallet).

    Annotations the server declares

    • title: Report the paid-analysis payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • invoice_report_paymentHand the payment transaction to the server, right after sending it.Reads text others writeNo findings

    Why it is in this group

    • The name "invoice_report_payment" says "payment": a word that usually means money moves, which cannot be taken back.

    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
    Hand the payment transaction to the server, right after sending it. The server reads the transaction on-chain and measures what reached the receiver in the invoice token; the payer must be the signer and the transaction must be newer than the invoice. The payer is screened again here (payer_blocked: a sanctioned or issuer-frozen payer does not count as paid, and once the network confirms the transaction the refusal is kept in the 10-year analysis record). With a paid analysis on the invoice and no prior proof of the payer wallet, the transaction itself is the proof: until the network confirms it the call returns payment_pending (409) and records nothing, so call again once it is mined. Pending until mined; invoice_get re-checks. An invoice holds at most 5 pending and 30 unconfirmed payments; past that, too_many_pending (429) until the network confirms the transaction, and a confirmed one is always accepted, so call again once it is mined. A hash pays each receiver once (tx_already_used once it confirmed another invoice of the same receiver and token); different receivers in one transaction are a batch payout.

    Annotations the server declares

    • title: Report an invoice payment
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • payout_batchPayroll and supplier payouts to many wallets in one batch, on Solana and on the nine EVM chains (those with loteSplit true in GET /v1/chains).Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "payout_batch" says "payout": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.recipients): what it sends cannot be taken back.

    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.recipients): what the tool writes goes there.

    Findings

    • Info

      The description is 3,981 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...t, too_many_recipients, token_not_listed, screening_unavailable (503, try again)."

      What this check looks for
    Description, as the server wrote it
    Payroll and supplier payouts to many wallets in one batch, on Solana and on the nine EVM chains (those with loteSplit true in GET /v1/chains). EVM: up to 50 wallets, in a verified USD stablecoin (USDC, USDT, PYUSD, USDG, USD1) — the batch is ONE transaction through the Vurto IBBs split contract, and the payer pays the exact amounts PLUS a 0.1% Vurto fee on the total. Solana: up to 20 wallets, in any token the payer holds (no swap, no fee), packed into one or a few transactions. The paying wallet and every receiving wallet are screened first (OFAC SDN list and, on Solana, the issuer freeze of six stablecoins); a blocked payer refuses with payer_blocked (403), and one blocked recipient refuses the whole batch with receiver_blocked (403) and details.index of that row, before anything is created. Each recipient becomes a regular invoice (history, on-chain verification). EVM returns { invoices[], evm: { split, invoiceIds[], base, fee, batchRef, deadline, steps[] } }: sign steps IN ORDER with prepare_signing (the approve step first, then the pay transaction step), send them, and call payout_report_payment with the PAY transaction hash and evm.invoiceIds. Solana returns { invoices[], transactions[] }: sign each transactions[i].transaction (prepare_signing, then POST to /v1/svm/execute) and call payout_report_payment with that signature and its invoiceIds. checks (stablecoin token, both families) adds a PAID analysis of every destination, turning the batch into two steps. Scorechain runs on every EVM chain and Solana; Merkle Science (Didit) does not cover Gnosis, Unichain or Avalanche, so a check the chain lacks refuses with check_not_available_on_chain. With checks the response carries no transactions[]: Solana returns { invoices[], charge: { buildId, transaction, loteId, total, token, tokenDecimals, feeWallet, recipients }, reused[] } (prepare_signing with buildId and step {transaction}, POST to /v1/svm/execute); EVM returns the same charge plus charge.step, a transaction step ready for prepare_signing. Sign the charge transaction exactly as returned: it carries the mark that ties the payment to this charge (16 bytes after the transfer arguments on EVM, a memo on Solana). A transfer you build yourself is refused with analysis_payment_rejected, reason charge_not_tied, after the money has left; do not pay again, prove the wallet (destination_challenge with wallet = payer, receiver = details.feeWallet, chargeId = this charge and chargeTxHash = that hash, then destination_authorize) and report the same hash again. A Solana transaction expires in about a minute: POST /v1/payouts/charge/transaction with loteId and payer returns the same charge fresh, without another batch; if it also returns reportedTxHash, send that hash to payout_charge instead of signing, or you may pay twice. To pay the fee with another token, swap_build with tokenOut = charge.token, receiver = charge.feeWallet and loteId, with a minimum between charge.total and 10% above it. Then call payout_charge with that loteId, the charge hash/signature and the payer to analyse every destination, drop the blocked and get the approved send: Solana as transactions[] to sign, EVM as evm (the IBBs approve + pay steps of ONLY the approved, with the 0.1% fee recomputed on the approved base, with buildId, chainId and invoiceIds; if evm.deadline passed, call payout_charge again for a fresh one). Not re-charging a wallet already analysed (reused[]) needs the payer's signed session, which the API does not carry, so via MCP every destination is charged and reused[] is empty. Errors: batch_not_available_on_chain (an EVM chain without the IBBs contract), stablecoin_required (a checks batch in a non-stablecoin token), check_not_available_on_chain (a paid check the chain lacks, e.g. Merkle on Gnosis/Unichain/Avalanche), batch_duplicate_recipient (add the amounts up in one row), batch_self_payment, too_many_recipients, token_not_listed, screening_unavailable (503, try again).

    Annotations the server declares

    • title: Build a batch payout
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • payout_chargeStep 2 of a payout_batch with checks, on Solana or EVM.Reads text others writeNo findings

    Why it is in this group

    • The name "payout_charge" says "payout": a word that usually means money moves, which cannot be taken back.

    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
    Step 2 of a payout_batch with checks, on Solana or EVM. After signing and sending payout_batch's charge.transaction, hand its signature or hash here with the loteId and payer. The server verifies the charge on-chain, runs the paid analysis on EVERY destination, EXCLUDES any wallet that is blocked or over the payer's risk threshold (it receives nothing, its money never moved), and returns { transactions[], evm?, approved[] (each with its scan result), rejected[] (wallet, reason) }. On Solana, sign each transactions[i].transaction (prepare_signing, POST to /v1/svm/execute) and call payout_report_payment with that signature and its invoiceIds. On EVM, sign evm.steps IN ORDER (approve, then pay the IBBs contract) and call payout_report_payment with the pay transaction hash and evm.invoiceIds. Idempotent with the same charge signature (re-returns the built batch, without the wallets already paid, listed in alreadyPaid). The charge hash goes only here, never to payout_report_payment. Errors: batch_charge_not_found, invalid_tx_hash, analysis_payment_pending (409, the network has not confirmed the charge yet, send the signature again shortly), analysis_payment_rejected (the transaction does not pay this charge; details.reason charge_not_tied when it is not the transaction payout_batch built: do not pay again, prove the wallet with destination_challenge (receiver = details.feeWallet, chargeId = the loteId, chargeTxHash = that hash), then destination_authorize, and call this again), tx_already_used.

    Annotations the server declares

    • title: Pay a batch analysis charge and build
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • payout_report_paymentHand one batch transaction to the server, right after sending it, with the invoiceIds that payout_batch listed for it.Reads text others writeNo findings

    Why it is in this group

    • The name "payout_report_payment" says "payout": a word that usually means money moves, which cannot be taken back.

    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
    Hand one batch transaction to the server, right after sending it, with the invoiceIds that payout_batch listed for it. Each invoice is verified on-chain like any invoice payment (what reached that receiver); call again a few seconds later if some are still pending.

    Annotations the server declares

    • title: Report a batch payout transaction
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • payout_reusePreview which wallets in a batch (Solana or EVM) ran this analysis for this payer in the last 30 days: a hint, read with no network call; whether it comes from the history is decid…Reads text others writeCan send data out1 finding

    Why it is in this group

    • The name "payout_reuse" says "payout": a word that usually means money moves, which cannot be taken back.
    • The input addresses people (input.recipients): 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.recipients): what the tool writes goes there.

    Findings

    • Warn

      The server marks "payout_reuse" 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 "payout_reuse" says "payout": a word that usually means money moves, which cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    Preview which wallets in a batch (Solana or EVM) ran this analysis for this payer in the last 30 days: a hint, read with no network call; whether it comes from the history is decided when the charge is paid, by the movement measured then; every one still pays its share of the fee. This reveals a payer's own analysis history, so it needs the paying wallet's signed session; the MCP carries no session, so paid is always [] and the batch charges every destination. With each recipient's amount and a USD stablecoin token it also returns fee { amount (dollars, the analysis charge payout_batch would build), charged (destinations in it), belowMinimum (indexes of the lines below the minimum, which go without the paid analysis), minimum }. Returns { paid: string[], fee? }.

    Annotations the server declares

    • title: Preview already-paid destinations
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • prepare_signingSynthesizes the local CLI signer invocation for one step of a swap_build plan.1 finding

    Why it is in this group

    • The input addresses people (input.step.tx.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "prepare_signing" 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":false}; The input addresses people (input.step.tx.to): what it sends cannot be taken back.

      What this check looks for
    Description, as the server wrote it
    Synthesizes the local CLI signer invocation for one step of a swap_build plan. Does not call the Vurto backend — this only assembles the payload. You (the agent) do not need a private key and must never ask for one in chat: signing happens locally on the user's machine. RUN the command yourself as a background task (it blocks until the user approves/rejects/times out, then prints one JSON line and exits) and react to its exit — never ask the user "did you sign?". EVM supports "approve"/"transaction" steps (send tx.to/tx.data on-chain) and "signature" steps (sign step.typedData off-chain, EIP-712 — a CoW order; no gas, no transaction, no hash). expected_keys in the response tells you which result field to read: txHash for the first two, signature for the third. Solana has no steps[] and no approve: pass chainId "solana-mainnet" and step {transaction: build.transaction, executionRef: build.executionRef}. The response returns a different signer (Solana keys are not EVM keys) with the same shape, and expected_keys is signedTransaction — POST it to /v1/svm/execute, which broadcasts it and returns the signature.

    Annotations the server declares

    • title: Assemble the local signer command
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
Changes things 15Claude Code: ask
  • check_accessThe Check access of a paying wallet, the proof check_credits asks for (access), valid 24 hours.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    The Check access of a paying wallet, the proof check_credits asks for (access), valid 24 hours. Hand here the signature of check_access_challenge with its nonce and message, unchanged. The challenge is consumed here, once, so the access goes only to whoever holds that signature: keep it secret, it lists this payer's Checks. A challenge of another kind (destination_challenge, the claim of another charge) is refused with check_access_challenge_invalid. Returns { access, payer, expiresAt }.

    Annotations the server declares

    • title: Check: get the access of a paying wallet
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • check_access_challengeOnly for check_credits (listing a payer's Checks by wallet); paying, analysing and reading one Check need only its id.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    Only for check_credits (listing a payer's Checks by wallet); paying, analysing and reading one Check need only its id. The challenge of the Check access, of its own: the text says what the signature grants (read and use the paid Checks of this wallet for 24 hours), the site and until when to sign, and that it moves no funds and authorizes no destination. chainId is any network check_info lists: on EVM it is the domain of typedData, on Solana it gives proofTransaction. Returns { nonce, message, expiresAt, buildId (check-access-<nonce>), typedData (EVM) | proofTransaction (Solana) }. Sign it with prepare_signing (EVM: a signature step with typedData; Solana: the proofTransaction, never sent), then call check_access. Never use destination_challenge or destination_authorize for the Check: they do not give an access.

    Annotations the server declares

    • title: Check: the text the paying wallet signs for its access
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • check_analyzeSpends ONE paid credit on the networks it paid: evmWallet on the EVM networks paid, solanaWallet on Solana if it was paid.Reads text others write1 finding

    Why it is in this group

    • The name "check_analyze" says "analyze": a word for reading.
    • The server marks it as not read-only (readOnlyHint: false).

    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 "check_analyze" as not read-only (readOnlyHint: false), and its words say it reads.

      Matched text

      annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "check_analyze" says "analyze": a word for reading.

      What this check looks for
    Description, as the server wrote it
    Spends ONE paid credit on the networks it paid: evmWallet on the EVM networks paid, solanaWallet on Solana if it was paid. Give a wallet for each family the credit paid (check_wallet_missing otherwise) and none for a family it did not (check_family_not_paid). The free screening (OFAC SDN, issuer freeze) and Scorechain read each wallet once, Merkle Science (through Didit) once per network, at most the networks paid plus 2 lookups in all. Returns check with status used, target { wallets { evm, svm }, networks }, seal (the worst network: red, risk found; yellow, medium risk; grey, a paid reading did not come back; green, no risk, Merkle no_data included), result and screening (of the worst network), networks [{ chainId, seal, result { verdict, risk, tools [{ tool, result clear|flagged|unavailable, score 0-100, severity, summary, category, factors, sourceOfFunds, destinationOfFunds, analyzedAt, fromHistory }], details }, screening }] and events (the real steps, with ms). The same credit and the same wallets again answers what is stored, with no provider call; other wallets are check_credit_used (409). Two calls at once run ONE analysis (the other gets check_running, 409). check_unreadable (503): a reading did not answer, the credit is still valid, call again with the same arguments (details.missing names tool:network). analysis_tool_unavailable (503): a tool is down and the credit was not touched.

    Annotations the server declares

    • title: Check: analyse a wallet with a credit
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • check_buy_challengeStep one of buying a Check (owner, 12/11/2026: only a wallet that passes the free screening buys, so it signs first).No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    Step one of buying a Check (owner, 12/11/2026: only a wallet that passes the free screening buys, so it signs first). The challenge of its own, scope buy: the text says this wallet pays for a Check and is screened before buying, valid 10 minutes, and that it moves no funds and authorizes no destination. chainId is any network check_info lists. Returns { nonce, message, expiresAt, buildId (check-buy-<nonce>), typedData (EVM) | proofTransaction (Solana) }. Sign it with prepare_signing, then call check_buy_proof.

    Annotations the server declares

    • title: Check: the text the paying wallet signs to buy
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • check_buy_proofHand here the signature of check_buy_challenge with its nonce and message, unchanged.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
    Hand here the signature of check_buy_challenge with its nonce and message, unchanged. The challenge is consumed once, the wallet goes through the free screening (OFAC, issuer freezes), and only if it passes it returns { buyProof (vcb_..., 10 minutes, secret), payer, screening: passed, expiresAt }. A blocked wallet gets payer_blocked (403). A challenge of another kind (check_access_challenge, destination_challenge) is refused with check_buy_challenge_invalid. Pass buyProof to check_charge.

    Annotations the server declares

    • title: Check: prove the paying wallet and screen it
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • check_creditsThe paid Checks of a paying wallet, newest first, 50 a page with nextCursor: unused credits (status paid), a reading in flight or interrupted (status running: call check_analyze ag…No 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.
    Description, as the server wrote it
    The paid Checks of a paying wallet, newest first, 50 a page with nextCursor: unused credits (status paid), a reading in flight or interrupted (status running: call check_analyze again with its target to resume) and the analyses already run (status used, with target and seal), to find a Check id you lost. The one check_* tool that reads by wallet, so the one that needs access, the Check access of this payer (check_access_challenge, then check_access).

    Annotations the server declares

    • title: Check: list this payer's Checks
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • check_infoThe paid Check of any wallet: price { maximum (dollars, one system variable, 1.99), perNetwork (the maximum divided by 6, down to the cent: 0.33), amount (= maximum, for older clie…No 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.
    Description, as the server wrote it
    The paid Check of any wallet: price { maximum (dollars, one system variable, 1.99), perNetwork (the maximum divided by 6, down to the cent: 0.33), amount (= maximum, for older clients), currency }; the price of a Check is perNetwork times the networks chosen, never above maximum. checkNetworks [{ chainId, family }] (the seven to choose: 1, 10, 56, 137, 8453, 42161, solana-mainnet), networks [{ chainId, family, token (the USDC that pays), feeWallet }] (where it is paid: the nine EVM networks and solana-mainnet), creditLimit and chargeValidSeconds (1800). Public, no proof needed.

    Annotations the server declares

    • title: Check: price, networks and fee wallets
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • destination_authorizeHand over the signature of destination_challenge.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
    Hand over the signature of destination_challenge. The server checks it is the paying wallet's signature over that exact challenge, for that receiver and chain, unexpired and unused, and then lets builds deliver to that receiver for 30 minutes. Nothing else unlocks it. Errors: signature_invalid, authorization_expired, authorization_replayed, authorization_destination_mismatch, authorization_network_mismatch.

    Annotations the server declares

    • title: Authorize another destination with the wallet signature
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • destination_challengeDestination lock.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
    Destination lock. A receiver different from the signing wallet is refused by swap_build, double_build and nn_build (403 destination_not_authorized) until the paying wallet signs an authorization for that exact address on that chain. This returns {nonce, message, expiresAt} plus, on EVM, typedData (EIP-712, the same fields) and, on Solana, proofTransaction (a memo that can never land, for Ledger). Show the user the full receiver and network and get their explicit yes; then sign: on EVM call prepare_signing with step {type: "signature", typedData} and run it; on Solana sign message (or proofTransaction) with the wallet. Then call destination_authorize. Never sign this without the user asking to send to that address. Paying an invoice to its receiver does not unlock through this, but an invoice with payerChecks asks for the same proof of the paying wallet (payer_signature_required).

    Annotations the server declares

    • title: Ask to send the output to another wallet
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • double_buildBuilds signable/sendable plans for BOTH legs of a Double Out or Double In swap — two ordinary swap_build calls under the hood, kept together for convenience.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
    Builds signable/sendable plans for BOTH legs of a Double Out or Double In swap — two ordinary swap_build calls under the hood, kept together for convenience. Returns { legA, legB }, each a full SwapPlan exactly like swap_build's. The two legs are NOT atomic — there is no combined contract call, each is a transaction (or CoW signature) the wallet sends separately, same as any other swap. Execute leg A fully first (steps, signing, report_execution) and confirm it landed before starting leg B. If leg A fails or is rejected, do NOT execute leg B — proceeding would leave the wallet with only half the ratio the user asked for, which defeats the purpose of a Double swap.

    Annotations the server declares

    • title: Build a two-leg plan
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • nn_buildBuilds ONE signable/sendable atomic transaction executing every leg of an N:N basket through VurtoSwapRouter.Reads text others write1 finding

    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.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...ss the wallet that will sign. A machine credential is optional and only raises your limit..."

      What this check looks for
    Description, as the server wrote it
    Builds ONE signable/sendable atomic transaction executing every leg of an N:N basket through VurtoSwapRouter. Always re-quotes the whole basket fresh from chainId/inputLegs/outputLegs — there is no quoteId handoff for N:N, pass the same fields used for nn_quote (or skip nn_quote and call this directly). No API key required: pass the wallet that will sign. A machine credential is optional and only raises your limit from the per-IP cap to the credential budget. Returns steps[]: one approve step per DISTINCT input token that still needs allowance, followed by ONE transaction step that executes every leg atomically. The approve target is the VurtoSwapRouter address (steps[].spender / the build's router), NOT each leg's underlying provider — this router pulls every input token itself inside one contract call, so approving providers individually the way swap_build does would approve the wrong address. If simulation.status is approval_required, send the approve step(s) first and call nn_build again for the executable transaction. legs[].routeSwitch, when present on a leg, means the provider the quote picked for THAT leg refused to build (it hit its request limit) and the leg was built with another provider instead: {from, to, reason}. Only that leg changed, the others are untouched, and the replacement is what will be signed: say which provider replaced it before the user signs. IMPORTANT: report_execution and swap_status do NOT support nn_build's transaction step — both key off a single quoteId, and this build has none (it is one transaction covering every leg, not one quote). After sending it, confirm success by checking the transaction receipt directly, not swap_status.

    Annotations the server declares

    • title: Build a basket plan
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • nn_quoteN:N — quotes a basket where N input tokens fund M output tokens in ONE atomic on-chain transaction.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
    N:N — quotes a basket where N input tokens fund M output tokens in ONE atomic on-chain transaction. The backend runs a waterfall allocation deciding which input finances which output, then quotes the real tokenIn->tokenOut route for each resulting slice through the same provider fan-out swap_quote uses. NOT decomposable into independent swap_quote/double_quote calls — the allocation itself is the thing being computed, not just N+M separate prices for legs you already know. inputLegs[]: what you sell (tokenIn + amount or amountRaw, each). outputLegs[]: what you want back, as outputPercent — an integer percent of the TOTAL basket value, not a fixed amount, because the actual split depends on the allocation; every outputLegs[].outputPercent in the request must sum to exactly 100. Up to 10 combined input+output legs; the waterfall never produces more than inputLegs.length + outputLegs.length - 1 real on-chain legs. Returns { legs[], failures[] }. Each entry in legs[] is a real quoted tokenIn->tokenOut leg (a NormalizedQuote under .quote, plus amountIn/tokenIn/tokenOut/receiver for that slice) — this is what nn_build will execute, not a rough preview. failures[] lists any slice that found no route; a partial basket is possible and reported, never silently dropped.

    Annotations the server declares

    • title: Compare basket routes
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • report_executionReports a completed swap, closing the loop.Reads text others write1 finding

    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.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...network. No API key required; a machine credential only raises limits."

      What this check looks for
    Description, as the server wrote it
    Reports a completed swap, closing the loop. EVM transaction: pass wallet + txHash + quoteId; never report an approve step as an execution. EVM CoW signature: pass wallet + chainId + quoteId + signature; the server reloads the stored build and submits the signed order, returning uid (there is no transaction hash for this path). Solana: pass buildId + signature; the server verifies the fee payer and transaction on the network. No API key required; a machine credential only raises limits.

    Annotations the server declares

    • title: Report a completed swap
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • swap_buildBuild a signable/sendable plan for a swap.Reads text others write1 finding

    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.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...ss the wallet that will sign. A machine credential is optional and only raises your limit..."

      What this check looks for
    Description, as the server wrote it
    Build a signable/sendable plan for a swap. This is the tool that does the work — an agent that only knows this tool can execute a swap end to end. Quotes and builds the best route in one call when quoteId is omitted (recommended): a route with GAIN first, re-quoting up to 3 rounds total before accepting one without gain, the same rule as Invoice; pass quoteId from a prior swap_quote to build exactly that route instead. No API key required: pass the wallet that will sign. A machine credential is optional and only raises your limit from the per-IP cap to the credential budget. Four things to hold onto: 1. steps[] are ORDERED and REQUIRED. Skipping an approve step guarantees a revert. 2. If simulation.status is "approval_required", sign/send only the approve step(s), do not report them as the swap execution, then call swap_build again with quoteId set to the quote.id of that build (the approved route; without it a fresh quote may pick another provider whose spender you never approved). If it is "incomplete", do not sign anything: the transaction was never independently verified. 3. If a step has type "signature", there is no transaction and never will be one for that step — what exists afterward is the uid from report_execution, not a hash. 4. If the provider is cowswap and the token sold is the chain's native asset, the transaction only REGISTERS the order — a successful receipt is not a successful swap. Use swap_status, not the receipt, to know what actually happened. 5. routeSwitch, when present, means the route you asked for refused to build (it hit its request limit) and the plan was built with another provider instead: {from, to, reason}. The quote in the plan is the route that will actually be signed. If the user picked that route themselves, say which provider replaced it before they sign.

    Annotations the server declares

    • title: Build a swap plan
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • wallet_checkCheck any wallet (EVM 0x address or Solana base58, case-sensitive) before paying it or taking its money: OFAC SDN list on both families; on Solana also the issuer freeze of USDC an…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
    Check any wallet (EVM 0x address or Solana base58, case-sensitive) before paying it or taking its money: OFAC SDN list on both families; on Solana also the issuer freeze of USDC and EURC (Circle), USDT (Tether), PYUSD and USDG (Paxos) and USD1 (World Liberty), the issuer freeze index, and a fund trail up to three hops back. Returns verdict passed, blocked or unavailable, with each check. Paying an invoice (invoice_pay) runs this check on the receiving wallet and refuses with receiver_blocked, so a payment through Vurto Payments never reaches a sanctioned or frozen wallet. To pay someone directly, create an invoice to their wallet (invoice_create) and pay it with invoice_pay. Plain swaps (swap_build, double_build, nn_build) do not run it. The Scorechain and Merkle Science checks are paid: buy them for any wallet with check_charge and check_analyze (the Check), or inside an invoice with invoice_analysis_pay; asking for them here returns paid_check_requires_invoice (400).

    Annotations the server declares

    • title: Check a wallet before paying
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
Only reads 5Show 5 read-only tools
  • check_resultReads one Check by its id, as stored (status, target, seal, result, screening, networks, events).No findings

    Why it is in this group

    • The description's first verb is "read": a word for reading.
    Description, as the server wrote it
    Reads one Check by its id, as stored (status, target, seal, result, screening, networks, events). Never calls a paid provider. An unknown id gets check_not_found (404).

    Annotations the server declares

    • title: Check: read a stored result
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • double_quoteCompares ranked routes for TWO swap legs at once — "Double Out" (one source token split into two destinations) or "Double In" (two source tokens converging on one destination).Reads text others writeNo findings

    Why it is in this group

    • The description's first verb is "compare": 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
    Compares ranked routes for TWO swap legs at once — "Double Out" (one source token split into two destinations) or "Double In" (two source tokens converging on one destination). This exists because building a liquidity pool or matching a target ratio needs both legs priced against the market at the same instant, not one after another with the price moving in between. Each leg is independently quoted (two ordinary swap_quote calls under the hood) — this tool is a convenience that keeps them together, not a combined/atomic route. For mode "out": legA.tokenIn must equal legB.tokenIn (the shared source); tokenOut differs. For mode "in": legA.tokenOut must equal legB.tokenOut (the shared destination); tokenIn differs. Pass the exact amount each leg should trade — this tool does not compute percentages or splits for you. If the shared token is the chain's native asset, remember gas is paid twice (once per leg's eventual transaction) — do not quote/build a total that leaves nothing for the second leg's gas.

    Annotations the server declares

    • title: Compare two-leg routes
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • invoice_getRead an invoice by id (INV-XXXX-XXXX, with or without dashes): requested amount, token, network, receiver, status (open or paid), the paying transaction once paid, and received (th…Reads text others writeNo findings

    Why it is in this group

    • The name "invoice_get" says "get": 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
    Read an invoice by id (INV-XXXX-XXXX, with or without dashes): requested amount, token, network, receiver, status (open or paid), the paying transaction once paid, and received (the raw amount measured on-chain so far). Pending payments are re-checked on-chain by the read, at most two per read and each at most every 15 seconds. checks lists the older paid screening of an invoice created before 07/11/2026 ([] for new ones), which paying runs on both wallets once analysis.status is paid; payerChecks lists the analysis of the paying wallet the receiver asked and paid for. receiverAnalysisFee, on an open invoice where the payer can buy the receiving wallet analysis (invoice_analysis_pay with checks): {available: true, amount} is the charge in dollars, the bracket fee of the invoice amount, or {available: false, minimum} when the amount is below the minimum and there is nothing to buy. For such an older invoice, analysis.report (Merkle Science only) carries, once the invoice is paid, the detail of both wallets; for payerChecks the result goes to the creator alone, on the site, and does not come here (over the web app, a signed session of the creator also sees the detail of the receiving wallet while it is open): score, severity, summary, main risk category, risk factors and sourceOfFunds (the largest origins of the money, up to 8, with category, entity, percentage, USD amount and direct or indirect exposure). confidential is true only on a private invoice created before 14/10/2026: its receiver reads null here, it can no longer be paid (invoice_pay answers private_invoice_paused), and its paying transaction, once paid, shows the receiver on-chain.

    Annotations the server declares

    • title: Read an invoice
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
  • swap_quoteCompare ranked routes across providers for a swap, without building or spending anything.Reads text others writeNo findings

    Why it is in this group

    • The description's first verb is "compare": 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
    Compare ranked routes across providers for a swap, without building or spending anything. Ranked by net value after gas and platform fee, not raw output, with ONE unit price for the output token across every route, so a friendlier price feed can never put a route that delivers fewer tokens on top. Each quote also carries estimatedGas, the gas in units behind the same gasUsd, if you would rather rank against a gas price you read yourself. A quote is only usable by swap_build for about 10-12 seconds — do not hold onto a quoteId and build it later, quote again instead.

    Annotations the server declares

    • title: Compare swap routes
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
  • swap_statusRe-checks a swap.Reads text others writeNo findings

    Why it is in this group

    • The name "swap_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
    Re-checks a swap. EVM: pass wallet + executionId (the id from report_execution); for CoW ETH-flow this consults the orderbook and distinguishes order_expired_refundable from order_expired_refunded instead of trusting the registration receipt. Solana: pass signature; answers come directly from the network and may be confirmed, pending, failed or expired.

    Annotations the server declares

    • title: Check a swap status
    • 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.

No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data.

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write25
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out3
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

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.

Tools listed without sign-in

Looked at Nov 20, 2026, 19:03 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
29
Protocol version
2025-03-26
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
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 29 tools that change things (12 irreversible, 17 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://swap.vurto.cc/mcp: tools/list returned 34 tools to an anonymous client, including prepare_signing (irreversible), invoice_create (irreversible), invoice_analysis_pay (irreversible), invoice_report_analysis_payment (irreversible), invoice_pay (irreversible) and 24 more

    What this check looks for

Posture changes

  1. Nov 20, 2026
    • Tools that change things, listed without credentials: 27 to 29
  2. Nov 13, 2026
    • Tools that change things, listed without credentials: 18 to 27
  3. Nov 6, 2026
    • Tools that change things, listed without credentials: 14 to 18

Findings

Matches of fixed checks, with the text they matched.

3 warn6 info
  • The server marks "prepare_signing" 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":false}; The input addresses people (input.step.tx.to): what it sends cannot be taken back.

    What this check looks for
  • The server marks "payout_reuse" 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 "payout_reuse" says "payout": a word that usually means money moves, which cannot be taken back.

    What this check looks for
  • The server marks "check_analyze" as not read-only (readOnlyHint: false), and its words say it reads.

    Matched text

    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "check_analyze" says "analyze": a word for reading.

    What this check looks for
  • The description mentions "credential".

    Matched text

    description: "...ss the wallet that will sign. A machine credential is optional and only raises your limit..."

    What this check looks for
  • The description mentions "credential".

    Matched text

    description: "...ss the wallet that will sign. A machine credential is optional and only raises your limit..."

    What this check looks for
  • The description mentions "credential".

    Matched text

    description: "...network. No API key required; a machine credential only raises limits."

    What this check looks for
Show 3 more findings
  • The description is 5,700 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...s.to) and invoiceId = this invoice. On EVM the payer pays with the USDC transfer."

    What this check looks for
  • The description is 5,693 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...available (503) means the screening could not finish, try again in a few seconds."

    What this check looks for
  • The description is 3,981 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...t, too_many_recipients, token_not_listed, screening_unavailable (503, try again)."

    What this check looks for

History

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

  1. PostureRemote posture changed. Tools that change things, listed without credentials: 27 -> 29.View diff
    • Tools that change things, listed without credentials: 27 to 29
  2. Tools12 added, 11 changed.+12 added~11 changedView diff
  3. PostureRemote posture changed. Tools that change things, listed without credentials: 18 -> 27.View diff
    • Tools that change things, listed without credentials: 18 to 27
  4. PostureRemote posture changed. Tools that change things, listed without credentials: 14 -> 18.View diff
    • Tools that change things, listed without credentials: 14 to 18
  5. Tools2 added, 5 changed.+2 added~5 changedView diff

Install

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

claude mcp add --transport http vurto-swap https://swap.vurto.cc/mcp
claude mcp add --transport http vurto-swap https://swap.vurto.cc/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__vurto-swap__swap_quote",
      "mcp__vurto-swap__double_quote",
      "mcp__vurto-swap__swap_status",
      "mcp__vurto-swap__invoice_get",
      "mcp__vurto-swap__check_result"
    ],
    "ask": [
      "mcp__vurto-swap__swap_build",
      "mcp__vurto-swap__double_build",
      "mcp__vurto-swap__nn_quote",
      "mcp__vurto-swap__nn_build",
      "mcp__vurto-swap__prepare_signing",
      "mcp__vurto-swap__report_execution",
      "mcp__vurto-swap__invoice_create",
      "mcp__vurto-swap__invoice_analysis_pay",
      "mcp__vurto-swap__invoice_report_analysis_payment",
      "mcp__vurto-swap__wallet_check",
      "mcp__vurto-swap__destination_challenge",
      "mcp__vurto-swap__destination_authorize",
      "mcp__vurto-swap__invoice_pay",
      "mcp__vurto-swap__payout_batch",
      "mcp__vurto-swap__payout_charge",
      "mcp__vurto-swap__payout_reuse",
      "mcp__vurto-swap__payout_report_payment",
      "mcp__vurto-swap__invoice_report_payment",
      "mcp__vurto-swap__check_info",
      "mcp__vurto-swap__check_access_challenge",
      "mcp__vurto-swap__check_access",
      "mcp__vurto-swap__check_buy_challenge",
      "mcp__vurto-swap__check_buy_proof",
      "mcp__vurto-swap__check_charge",
      "mcp__vurto-swap__check_report_payment",
      "mcp__vurto-swap__check_analyze",
      "mcp__vurto-swap__check_credits"
    ],
    "deny": []
  }
}

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 vurto-swap. Review it before you use it.

Capability tags behind 25 rules
  • mcp__vurto-swap__swap_quote untrusted-input
  • mcp__vurto-swap__swap_build untrusted-input
  • mcp__vurto-swap__double_quote untrusted-input
  • mcp__vurto-swap__double_build untrusted-input
  • mcp__vurto-swap__nn_quote untrusted-input
  • mcp__vurto-swap__nn_build untrusted-input
  • mcp__vurto-swap__report_execution untrusted-input
  • mcp__vurto-swap__swap_status untrusted-input
  • mcp__vurto-swap__invoice_create untrusted-input, outbound
  • mcp__vurto-swap__invoice_analysis_pay untrusted-input
  • mcp__vurto-swap__invoice_report_analysis_payment untrusted-input
  • mcp__vurto-swap__wallet_check untrusted-input
  • mcp__vurto-swap__destination_challenge untrusted-input
  • mcp__vurto-swap__destination_authorize untrusted-input
  • mcp__vurto-swap__invoice_get untrusted-input
  • mcp__vurto-swap__invoice_pay untrusted-input
  • mcp__vurto-swap__payout_batch untrusted-input, outbound
  • mcp__vurto-swap__payout_charge untrusted-input
  • mcp__vurto-swap__payout_reuse untrusted-input, outbound
  • mcp__vurto-swap__payout_report_payment untrusted-input
  • mcp__vurto-swap__invoice_report_payment untrusted-input
  • mcp__vurto-swap__check_buy_proof untrusted-input
  • mcp__vurto-swap__check_charge untrusted-input
  • mcp__vurto-swap__check_report_payment untrusted-input
  • mcp__vurto-swap__check_analyze 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/io.github.cryptoconspiracy/vurto-swap/verify?hash=b2308bb2db524e2d9928e3f344667349afcf586111119b3da156161032a5ddb5" | jq -e '.changed == false'

Pinned hash b2308bb2db52, from Nov 17, 2026, 00:18 UTC.

Watch

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

https://radar.anlyon.com/servers/io.github.cryptoconspiracy/vurto-swap/changes.xml

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

Badge

Anlyon Radar badge for io.github.cryptoconspiracy/vurto-swap
[![Anlyon Radar](https://radar.anlyon.com/badge/io.github.cryptoconspiracy/vurto-swap.svg)](https://radar.anlyon.com/servers/io.github.cryptoconspiracy/vurto-swap)

Source: MCP Registry. Synced Oct 21, 2026, 18:28 UTC.

Vurto Swap MCP server: questions and answers

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

Is the Vurto Swap MCP server safe?

No scan can promise that. What its definitions show: 32 tools, 27 of which can change, send or delete something, and 9 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 Vurto Swap MCP server delete data?

No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.

Can the Vurto Swap MCP server do things that cannot be undone?

Yes. 12 tools can send, pay, publish or merge: prepare_signing, invoice_create, invoice_analysis_pay, invoice_report_analysis_payment, invoice_pay, payout_batch and 6 more.

What tools does the Vurto Swap MCP server have?

32 tools: 12 irreversible, 15 write, 5 read. prepare_signing, invoice_create, invoice_analysis_pay, invoice_report_analysis_payment, invoice_pay, payout_batch, payout_charge, payout_reuse and 24 more.

Does the Vurto Swap MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Vurto Swap MCP server send data to outside services?

3 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): invoice_create, payout_batch and payout_reuse.

Has the Vurto Swap MCP server changed its tools?

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