Servers Playground How we check Add a server Log in

Vurto Swap

Working · 2.1 s

io.github.cryptoconspiracy/vurto-swapv1.0.0

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

Crypto & Web3

Website Registry entry

Maintain this server? Claim it

Try it

Call this server's tools from your browser. Nothing to install.

https://swap.vurto.cc/mcp

Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.

Tool list from our last check. Connect live to refresh it.

destination_authorize

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.

noncestring, required

From destination_challenge.

walletstring, required

chainIdinteger, required

messagestring, required

From destination_challenge, unchanged.

receiverstring, required

signaturestring

EVM: 0x hex, EIP-712 over typedData or EIP-191 over message. Solana: base58 over message.

transactionstring

Solana only: the signed proofTransaction, base64, instead of signature.

This tool isn't marked read-only, so it may change something on the server or in an account you connected.

I understand, run it anyway

Vurto Swap MCP server | mcptry

Tools (18)

destination_authorize

Argument	Type	Description
nonce*	string	From destination_challenge.
wallet*	string
chainId*	integer \| string
message*	string	From destination_challenge, unchanged.
receiver*	string
signature	string	EVM: 0x hex, EIP-712 over typedData or EIP-191 over message. Solana: base58 over message.
transaction	string	Solana only: the signed proofTransaction, base64, instead of signature.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "wallet",
    "receiver",
    "chainId",
    "nonce",
    "message"
  ],
  "properties": {
    "nonce": {
      "type": "string",
      "description": "From destination_challenge."
    },
    "wallet": {
      "type": "string"
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ]
    },
    "message": {
      "type": "string",
      "description": "From destination_challenge, unchanged."
    },
    "receiver": {
      "type": "string"
    },
    "signature": {
      "type": "string",
      "description": "EVM: 0x hex, EIP-712 over typedData or EIP-191 over message. Solana: base58 over message."
    },
    "transaction": {
      "type": "string",
      "description": "Solana only: the signed proofTransaction, base64, instead of signature."
    }
  },
  "additionalProperties": false
}

destination_challenge

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 does not need it.

Argument	Type	Description
wallet*	string	The wallet that pays and signs.
chainId*	integer \| string	EVM chain id, or "solana-mainnet".
receiver*	string	The full destination address. Solana base58 is case-sensitive.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "wallet",
    "receiver",
    "chainId"
  ],
  "properties": {
    "wallet": {
      "type": "string",
      "description": "The wallet that pays and signs."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM chain id, or \"solana-mainnet\"."
    },
    "receiver": {
      "type": "string",
      "description": "The full destination address. Solana base58 is case-sensitive."
    }
  },
  "additionalProperties": false
}

double_build

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.

Argument	Type	Description
legA*	object
legB*	object
wallet*	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
chainId*	integer \| string	EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
maxSlippageBps	integer	Optional ceiling, 0-10000, applied to both legs.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "wallet",
    "legA",
    "legB"
  ],
  "properties": {
    "legA": {
      "type": "object",
      "properties": {
        "amount": {
          "type": "string",
          "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
        },
        "wallet": {
          "type": "string",
          "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
        },
        "chainId": {
          "type": [
            "integer",
            "string"
          ],
          "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
        },
        "quoteId": {
          "type": "string",
          "description": "Optional: build exactly this route from a prior double_quote."
        },
        "tokenIn": {
          "type": "string",
          "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
        },
        "receiver": {
          "type": "string",
          "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
        },
        "tokenOut": {
          "type": "string",
          "description": "Contract address, or symbol."
        },
        "amountRaw": {
          "type": "string",
          "description": "Raw integer string in tokenIn's smallest unit."
        },
        "slippageBps": {
          "type": "integer",
          "description": "Optional, a sane per-pair default applies when omitted."
        }
      },
      "additionalProperties": false
    },
    "legB": {
      "type": "object",
      "properties": {
        "amount": {
          "type": "string",
          "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
        },
        "wallet": {
          "type": "string",
          "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
        },
        "chainId": {
          "type": [
            "integer",
            "string"
          ],
          "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
        },
        "quoteId": {
          "type": "string"
        },
        "tokenIn": {
          "type": "string",
          "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
        },
        "receiver": {
          "type": "string",
          "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
        },
        "tokenOut": {
          "type": "string",
          "description": "Contract address, or symbol."
        },
        "amountRaw": {
          "type": "string",
          "description": "Raw integer string in tokenIn's smallest unit."
        },
        "slippageBps": {
          "type": "integer",
          "description": "Optional, a sane per-pair default applies when omitted."
        }
      },
      "additionalProperties": false
    },
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    },
    "maxSlippageBps": {
      "type": "integer",
      "description": "Optional ceiling, 0-10000, applied to both legs."
    }
  },
  "additionalProperties": false
}

double_quote

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.

read-only

Argument	Type	Description
legA*	object
legB*	object
mode*	string	"out": one source, two destinations. "in": two sources, one destination.
wallet	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
chainId*

invoice_create

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; it previews with the QR on WhatsApp and Telegram) and invoice.qr (PNG). No signature or API key needed. Only VERIFIED tokens of the network are accepted, 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. Optional checks: ["scorechain"] adds the Scorechain sanctions API to the screening of BOTH wallets (payer and receiver) whenever this invoice is paid; it sends both wallets to Scorechain, a third party, so it runs only when chosen. A wallet listed by Scorechain is refused (payer_blocked or receiver_blocked); when Scorechain cannot be read the payment is not held, because the OFAC list is already checked here.

Argument	Type	Description
memo	string	Optional note, up to 80 chars, visible to anyone with the link.
token*	string	Token to receive: address/mint or symbol of a verified token on this network.
amount*	string	Human decimal amount, e.g. "100". Decimals come from the token list, not from you.
checks	array	Optional extra screening chosen by the invoice creator; default none. "scorechain": when this invoice is paid, both wallets (payer and receiver) are also checked against the Scorechain sanctions API, which means both are sent to Scorechain. Runs only when chosen. Any other value is refused with invalid_check.
chainId

invoice_get

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 extra screening the creator chose (e.g. ["scorechain"]; [] when none), which paying runs on both wallets. 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.

read-only

Argument	Type	Description
id*	string	INV-XXXX-XXXX or the 8-character id.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "INV-XXXX-XXXX or the 8-character id."
    }
  },
  "additionalProperties": false
}

invoice_pay

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 the Scorechain sanctions API, so this call sends the payer wallet and the receiver wallet to Scorechain, a third party. 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. 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 vault 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.

Argument	Type	Description
id*	string	INV-XXXX-XXXX or the 8-character id.
payer*	string	The wallet that will sign and pay, on the invoice network.

invoice_report_payment

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). 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.

Argument	Type	Description
id*	string	INV-XXXX-XXXX or the 8-character id.
payer*	string	The wallet that signed the payment.
method	string	From invoice_pay.method.
txHash*	string	EVM transaction hash, or the Solana signature.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "id",
    "payer",
    "txHash"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "INV-XXXX-XXXX or the 8-character id."
    },
    "payer": {
      "type": "string",
      "description": "The wallet that signed the payment."
    },
    "method": {
      "enum": [
        "transfer",
        "swap"
      ],
      "type": "string",
      "description": "From invoice_pay.method."
    },
    "txHash": {
      "type": "string",
      "description": "EVM transaction hash, or the Solana signature."
    }
  },
  "additionalProperties": false
}

nn_build

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.

Argument	Type	Description
wallet*	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
chainId*	integer \| string	EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").

nn_quote

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.

read-only

Argument	Type	Description
wallet	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
chainId*	integer \| string	EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). On EVM the multi-swap router must be deployed on the chain or the quote fails with multi_swap_not_supported_on_chain; on Solana there is no router contract, several top-level instructions in one transaction are already all-or-nothing by runtime rule.

payout_batch

Payroll and supplier payouts on Solana: pay up to 20 wallets their exact amounts, in the token the payer holds (no swap). The paying wallet and every receiving wallet are screened first (OFAC SDN list and 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). Returns { invoices[], transactions[] }: the transfers are packed in as few transactions as fit the network limit, each with its invoiceIds. Sign each transactions[i].transaction (prepare_signing, then POST to /v1/svm/execute), then payout_report_payment with that signature and those invoiceIds. Errors: batch_svm_only, batch_duplicate_recipient (add the amounts up in one row), batch_self_payment, too_many_recipients, token_not_listed, screening_unavailable (503, try again).

Argument	Type	Description
payer*	string	The wallet that signs and pays.
token*	string	Mint or symbol of a verified token, e.g. "USDC". Every recipient is paid in it.
chainId*	string
recipients*	array

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "token",
    "payer",
    "recipients"
  ],
  "properties": {
    "payer": {
      "type": "string",
      "description": "The wallet that signs and pays."
    },
    "token": {
      "type": "string",
      "description": "Mint or symbol of a verified token, e.g. \"USDC\". Every recipient is paid in it."
    },
    "chainId": {
      "enum": [
        "solana-mainnet"
      ],
      "type": "string"
    },
    "recipients": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "wallet",
          "amount"
        ],
        "properties": {
          "memo": {
            "type": "string",
            "description": "Optional note, up to 80 characters."
          },
          "amount": {
            "type": "string",
            "description": "Human amount, e.g. \"500\" or \"120.5\". Exactly this reaches the wallet."
          },
          "wallet": {
            "type": "string",
            "description": "Receiving wallet (base58, case-sensitive). The payer cannot be one of them, and each wallet appears once."
          }
        },
        "additionalProperties": false
      },
      "maxItems": 20,
      "minItems": 1
    }
  },
  "additionalProperties": false
}

payout_report_payment

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.

Argument	Type	Description
payer*	string	The wallet that signed.
txHash*	string	The Solana signature.
invoiceIds*	array	From payout_batch.transactions[i].invoiceIds.

Input schema (JSON)

{
  "type": "object",
  "required": [
    "txHash",
    "payer",
    "invoiceIds"
  ],
  "properties": {
    "payer": {
      "type": "string",
      "description": "The wallet that signed."
    },
    "txHash": {
      "type": "string",
      "description": "The Solana signature."
    },
    "invoiceIds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 20,
      "minItems": 1,
      "description": "From payout_batch.transactions[i].invoiceIds."
    }
  },
  "additionalProperties": false
}

prepare_signing

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.

read-only

Argument	Type	Description
step*	object	EVM: one entry from swap_build's steps[]. Solana: {transaction, executionRef} from the build.
buildId*	string	From a prior swap_build/swap_refresh response.
chainId*	integer \| string	EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
walletAddress*

report_execution

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.

Argument	Type	Description
txHash	string	EVM transaction swap only; do not report approve hashes.
wallet	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
buildId	string	Solana: buildId returned by swap_build.
chainId	integer \| string	EVM CoW: integer chain id. Solana may use "solana-mainnet", but buildId + signature are sufficient.
quoteId	string	EVM: quote id from the built plan.
signature	string	EVM: EIP-712 CoW signature. Solana: transaction signature.

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "txHash": {
      "type": "string",
      "pattern": "^0x[0-9a-fA-F]{64}$",
      "description": "EVM transaction swap only; do not report approve hashes."
    },
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "buildId": {
      "type": "string",
      "description": "Solana: buildId returned by swap_build."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM CoW: integer chain id. Solana may use \"solana-mainnet\", but buildId + signature are sufficient."
    },
    "quoteId": {
      "type": "string",
      "description": "EVM: quote id from the built plan."
    },
    "signature": {
      "type": "string",
      "description": "EVM: EIP-712 CoW signature. Solana: transaction signature."
    }
  },
  "additionalProperties": false
}

swap_build

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.

Argument	Type	Description
amount	string	Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
wallet*	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

swap_quote

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.

read-only

Argument	Type	Description
amount	string	Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
wallet	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
chainId*	integer \| string	EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
tokenIn*	string	Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint.
receiver

swap_status

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.

read-only

Argument	Type	Description
wallet	string	Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.
signature	string	Solana: the transaction signature. Answers come from the network itself: confirmed, pending, failed, or expired (past lastValidBlockHeight the transaction can no longer enter any block).
executionId	string	EVM: the id returned by report_execution.

Input schema (JSON)

{
  "type": "object",
  "required": [],
  "properties": {
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "signature": {
      "type": "string",
      "description": "Solana: the transaction signature. Answers come from the network itself: confirmed, pending, failed, or expired (past lastValidBlockHeight the transaction can no longer enter any block)."
    },
    "executionId": {
      "type": "string",
      "description": "EVM: the id returned by report_execution."
    }
  },
  "additionalProperties": false
}

wallet_check

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. Optional checks: ["scorechain"] also asks the Scorechain sanctions API; it sends the wallet to Scorechain, a third party, so it runs only when chosen, and has a tighter per-IP limit (10 per hour). Its line reads listed, clear or unavailable; unavailable does not hold the verdict.

read-only

Argument	Type	Description
checks	array	Optional extra checks; default none. "scorechain" sends this wallet to the Scorechain sanctions API and adds a scorechain line (listed, clear or unavailable). Runs only when chosen; limited to 10 per hour per IP. Any other value is refused with invalid_check.
wallet*	string	The wallet to check. EVM 0x address, or Solana base58 (case-sensitive).

Input schema (JSON)

{
  "type": "object",
  "required": [
    "wallet"
  ],
  "properties": {
    "checks": {
      "type": "array",
      "items": {
        "enum": [
          "scorechain"
        ],
        "type": "string"
      },
      "description": "Optional extra checks; default none. \"scorechain\" sends this wallet to the Scorechain sanctions API and adds a scorechain line (listed, clear or unavailable). Runs only when chosen; limited to 10 per hour per IP. Any other value is refused with invalid_check."
    },
    "wallet": {
      "type": "string",
      "description": "The wallet to check. EVM 0x address, or Solana base58 (case-sensitive)."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "mode",
    "chainId",
    "legA",
    "legB"
  ],
  "properties": {
    "legA": {
      "type": "object",
      "required": [
        "tokenIn",
        "tokenOut"
      ],
      "properties": {
        "amount": {
          "type": "string",
          "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
        },
        "wallet": {
          "type": "string",
          "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
        },
        "chainId": {
          "type": [
            "integer",
            "string"
          ],
          "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
        },
        "tokenIn": {
          "type": "string",
          "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
        },
        "receiver": {
          "type": "string",
          "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
        },
        "tokenOut": {
          "type": "string",
          "description": "Contract address, or symbol."
        },
        "amountRaw": {
          "type": "string",
          "description": "Raw integer string in tokenIn's smallest unit."
        },
        "slippageBps": {
          "type": "integer",
          "description": "Optional, a sane per-pair default applies when omitted."
        }
      },
      "additionalProperties": false
    },
    "legB": {
      "type": "object",
      "required": [
        "tokenIn",
        "tokenOut"
      ],
      "properties": {
        "amount": {
          "type": "string",
          "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
        },
        "wallet": {
          "type": "string",
          "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
        },
        "chainId": {
          "type": [
            "integer",
            "string"
          ],
          "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
        },
        "tokenIn": {
          "type": "string",
          "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
        },
        "receiver": {
          "type": "string",
          "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
        },
        "tokenOut": {
          "type": "string",
          "description": "Contract address, or symbol."
        },
        "amountRaw": {
          "type": "string",
          "description": "Raw integer string in tokenIn's smallest unit."
        },
        "slippageBps": {
          "type": "integer",
          "description": "Optional, a sane per-pair default applies when omitted."
        }
      },
      "additionalProperties": false
    },
    "mode": {
      "enum": [
        "out",
        "in"
      ],
      "type": "string",
      "description": "\"out\": one source, two destinations. \"in\": two sources, one destination."
    },
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "wallet",
    "inputLegs",
    "outputLegs"
  ],
  "properties": {
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    },
    "inputLegs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tokenIn"
        ],
        "properties": {
          "amount": {
            "type": "string",
            "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
          },
          "tokenIn": {
            "type": "string",
            "description": "Contract address, or symbol (case-insensitive)."
          },
          "amountRaw": {
            "type": "string",
            "description": "Raw integer string in tokenIn's smallest unit."
          }
        },
        "additionalProperties": false
      },
      "minItems": 1
    },
    "outputLegs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tokenOut",
          "outputPercent"
        ],
        "properties": {
          "receiver": {
            "type": "string",
            "description": "Optional: deliver this leg's output to a different address than the signing wallet."
          },
          "tokenOut": {
            "type": "string",
            "description": "Contract address, or symbol."
          },
          "outputPercent": {
            "type": "integer",
            "description": "Integer percent (1-100) of the TOTAL basket value this leg receives. Every outputLegs[].outputPercent in the request must sum to exactly 100."
          }
        },
        "additionalProperties": false
      },
      "minItems": 1
    },
    "slippageBps": {
      "type": "integer",
      "description": "Optional, 5-500, applied to every leg. Default 50."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "inputLegs",
    "outputLegs"
  ],
  "properties": {
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\"). On EVM the multi-swap router must be deployed on the chain or the quote fails with multi_swap_not_supported_on_chain; on Solana there is no router contract, several top-level instructions in one transaction are already all-or-nothing by runtime rule."
    },
    "inputLegs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tokenIn"
        ],
        "properties": {
          "amount": {
            "type": "string",
            "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
          },
          "tokenIn": {
            "type": "string",
            "description": "Contract address, or symbol (case-insensitive)."
          },
          "amountRaw": {
            "type": "string",
            "description": "Raw integer string in tokenIn's smallest unit."
          }
        },
        "additionalProperties": false
      },
      "minItems": 1
    },
    "outputLegs": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tokenOut",
          "outputPercent"
        ],
        "properties": {
          "receiver": {
            "type": "string",
            "description": "Optional: deliver this leg's output to a different address than the signing wallet."
          },
          "tokenOut": {
            "type": "string",
            "description": "Contract address, or symbol."
          },
          "outputPercent": {
            "type": "integer",
            "description": "Integer percent (1-100) of the TOTAL basket value this leg receives. Every outputLegs[].outputPercent in the request must sum to exactly 100."
          }
        },
        "additionalProperties": false
      },
      "minItems": 1
    },
    "slippageBps": {
      "type": "integer",
      "description": "Optional, 5-500, applied to every leg. Default 50."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "buildId",
    "walletAddress",
    "chainId",
    "step"
  ],
  "properties": {
    "step": {
      "type": "object",
      "properties": {
        "tx": {
          "type": "object",
          "properties": {
            "to": {
              "type": "string"
            },
            "data": {
              "type": "string"
            },
            "value": {
              "type": "string"
            }
          },
          "description": "Required when type is \"approve\" or \"transaction\"."
        },
        "type": {
          "enum": [
            "approve",
            "transaction",
            "signature"
          ],
          "type": "string",
          "description": "EVM only."
        },
        "typedData": {
          "type": "object",
          "properties": {
            "types": {
              "type": "object"
            },
            "domain": {
              "type": "object"
            },
            "message": {
              "type": "object"
            },
            "primaryType": {
              "type": "string"
            }
          },
          "description": "Required when type is \"signature\" — pass steps[].typedData from swap_build verbatim."
        },
        "transaction": {
          "type": "string",
          "description": "Solana only: build.transaction, base64, verbatim."
        },
        "executionRef": {
          "type": "string",
          "description": "Solana only: build.executionRef when the build has one. Its absence is meaningful, not an omission: a route we assembled ourselves is broadcast directly, an aggregator order has to go back to the aggregator to land."
        },
        "humanSummary": {
          "type": "string"
        }
      },
      "description": "EVM: one entry from swap_build's steps[]. Solana: {transaction, executionRef} from the build."
    },
    "buildId": {
      "type": "string",
      "description": "From a prior swap_build/swap_refresh response."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    },
    "walletAddress": {
      "type": "string",
      "description": "The wallet the plan was built for. The signer refuses to sign if the connected wallet does not match. On Solana this is base58 and CASE-SENSITIVE: lowercasing it produces a different, non-existent address."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "wallet"
  ],
  "properties": {
    "amount": {
      "type": "string",
      "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
    },
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    },
    "quoteId": {
      "type": "string",
      "description": "Optional: build exactly this route from a prior swap_quote, instead of quoting fresh."
    },
    "tokenIn": {
      "type": "string",
      "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
    },
    "receiver": {
      "type": "string",
      "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
    },
    "tokenOut": {
      "type": "string",
      "description": "Contract address, or symbol."
    },
    "amountRaw": {
      "type": "string",
      "description": "Raw integer string in tokenIn's smallest unit."
    },
    "slippageBps": {
      "type": "integer",
      "description": "Optional, a sane per-pair default applies when omitted."
    },
    "maxSlippageBps": {
      "type": "integer",
      "description": "Optional ceiling, 0-10000, enforced on every future refresh of this build — once set it never loosens."
    }
  },
  "additionalProperties": false
}

Input schema (JSON)

{
  "type": "object",
  "required": [
    "chainId",
    "tokenIn",
    "tokenOut"
  ],
  "properties": {
    "amount": {
      "type": "string",
      "description": "Human decimal amount, e.g. \"100\". Use this OR amountRaw, not both."
    },
    "wallet": {
      "type": "string",
      "description": "Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative."
    },
    "chainId": {
      "type": [
        "integer",
        "string"
      ],
      "description": "EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains (\"solana-mainnet\")."
    },
    "tokenIn": {
      "type": "string",
      "description": "Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint."
    },
    "receiver": {
      "type": "string",
      "description": "Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized."
    },
    "tokenOut": {
      "type": "string",
      "description": "Contract address, or symbol."
    },
    "amountRaw": {
      "type": "string",
      "description": "Raw integer string in tokenIn's smallest unit."
    },
    "slippageBps": {
      "type": "integer",
      "description": "Optional, a sane per-pair default applies when omitted."
    }
  },
  "additionalProperties": false
}