OneDex MCP server

Non-custodial swap tools for AI agents on MultiversX. Quotes and unsigned transactions through the OneDex aggregator; a wallet you control signs and broadcasts.

The OneDex MCP server exposes six tools over the Model Context Protocol (Streamable HTTP). An agent can find tokens, read balances, price a swap, get a ready-to-sign transaction, dry-run it, and track it after broadcast. Routing goes through the OneDex aggregator (OneDex + xExchange pools); XOXNO is used only when it is clearly better and its whole route stays in verified xExchange pools. Agents therefore get OneDex and xExchange liquidity; the AshSwap and JEX routes available in the OneDex app are not used by the MCP server.

Use this when

Do not use this when

Connect your MCP client

No API key is needed. Point any MCP client at the endpoint below. Transport: MCP Streamable HTTP, stateless, JSON responses (POST only). Per-IP rate limits apply (see Limits). Health check: GET https://aggregator.onedex.app/ai/health.

https://aggregator.onedex.app/ai/mcp

Claude (web or desktop): custom connector

1. Open Settings → Connectors → Add custom connector.
2. Name: OneDex. URL: https://aggregator.onedex.app/ai/mcp.
3. No authentication.

Claude Code

claude mcp add --transport http onedex https://aggregator.onedex.app/ai/mcp

Cursor

Add the server to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "onedex": {
      "url": "https://aggregator.onedex.app/ai/mcp"
    }
  }
}

Generic MCP config

Most clients that read an mcpServers block accept a remote HTTP server like this. Key names vary slightly by client; what matters is the URL and the Streamable HTTP transport.

{
  "mcpServers": {
    "onedex": {
      "type": "http",
      "url": "https://aggregator.onedex.app/ai/mcp"
    }
  }
}

ChatGPT (developer mode)

In ChatGPT on the web. Custom MCP connectors need a paid plan and developer mode (beta); menu labels vary by plan and over time. See OpenAI's Connectors in ChatGPT.

1. Open Settings → Apps & Connectors (or Connectors) → Advanced and enable Developer mode.
2. Back in Apps & Connectors, select Create.
3. Name: OneDex. Server URL: https://aggregator.onedex.app/ai/mcp. Authentication: None. Confirm and create.

TypeScript SDK

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const client = new Client({ name: 'my-agent', version: '1.0.0' });
await client.connect(new StreamableHTTPClientTransport(new URL('https://aggregator.onedex.app/ai/mcp')));

const { tools } = await client.listTools();
const quote = await client.callTool({
  name: 'get_quote',
  arguments: { tokenIn: 'EGLD', tokenOut: 'ONE', amountIn: '1' }
});
console.log(quote.structuredContent);

Raw JSON-RPC (curl)

The server is stateless: no session header is needed between calls.

curl -s -X POST https://aggregator.onedex.app/ai/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

curl -s -X POST https://aggregator.onedex.app/ai/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

{
  "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": { "tools": { "listChanged": true } },
    "serverInfo": { "name": "onedex", "version": "0.1.0" },
    "instructions": "OneDex swap tools for MultiversX. Non-custodial: this server returns quotes and UNSIGNED transactions; …"
  },
  "jsonrpc": "2.0",
  "id": 1
}

tools/list returns the six tools with their JSON input schemas. Call a tool with:

"method":"tools/call","params":{"name":"get_quote","arguments":{"tokenIn":"EGLD","tokenOut":"ONE","amountIn":"1"}}

From quote to confirmed swap

1. Find tokens and funds. Call list_tokens (optional search) to resolve tickers to identifiers, and get_wallet_balances to see what the wallet holds.
2. Quote. Call get_quote with tokenIn, tokenOut and amountIn as a decimal string. Show the user costSummary, minOut and every entry of warnings, and keep the minOut the user approved.
3. Build. Call build_swap_tx with the same inputs plus sender (the signing wallet's erd1… address). You get an unsigned transaction, a human-readable summary, expiresAt and signingLink. Its minOut is fresh, for the exact amount: if it is lower than the one the user approved, show it and ask again. If transaction.nonce is missing, do not sign (see Errors & recovery).
4. Simulate (required). Pass the transaction unchanged and minOut.raw to simulate_swap_tx, in both human and autonomous flows. Stop if status is fail or meetsMinOut is false. If meetsMinOut is "—": an autonomous agent stops; in a human flow, show it to the user.
5. Sign and broadcast with your wallet. Check the transaction and the nonce, sign locally (or a person opens signingLink), broadcast to the MultiversX gateway. This server is not involved in this step. See Signing.
6. Track. Call tx_status with the transaction hash. Report the swap as done when status is success (or failed on fail); call it final only when finality is final.

What to call for each request

How an agent should map a user's request to the six tools. The same matrix, with the agent's operating rules, is in agent-instructions.md (plain Markdown, ready to paste into a system prompt).

What this server does not do

Agents should not promise these, and should not try to work around them with the six tools.

Tool reference

Every tool takes an optional network ("mainnet", the default; "devnet" is not available on the public server). Results are JSON in structuredContent (and the same JSON as text). Tokens can be given as "EGLD", an identifier ("ONE-f9954f") or a ticker that matches exactly one tradable token ("USDC").

Errors are returned as a tool result with isError: true and the text {"error":{"code":"…","message":"…"}}. Invalid arguments are rejected by schema validation before the tool runs. Examples below are trimmed responses from a live run against mainnet (read-only, Nov 2026). Long addresses and data are shortened with …; wallet addresses, transaction hashes and wallet-specific values are replaced with marked example values.

{
  "network": "mainnet",
  "total": 11,
  "data": { "tokens": [
    { "id": "ONE-f9954f", "ticker": "ONE", "name": "OneDex", "decimals": 18,
      "priceUsd": "0.006651717007044685", "liquidityUsd": "22214",
      "verified": true, "paused": false, "lowLiquidity": false },
    { "id": "XMN-cfe145", "ticker": "XMN", "name": "xMoneyToken", "decimals": 6,
      "priceUsd": "0.000221737132273238", "liquidityUsd": "7195",
      "verified": true, "paused": false, "lowLiquidity": true }
  ] }
}

{
  "network": "mainnet",
  "totalValueUsd": "32.59",
  "tokenCount": 1,
  "truncated": false,
  "warnings": [],
  "data": { "balances": [
    { "token": "EGLD", "ticker": "EGLD", "name": "MultiversX eGold (native)", "decimals": 18,
      "balance": { "decimal": "12.5", "raw": "12500000000000000000" },
      "priceUsd": "2.6070432376154336", "valueUsd": "32.59" }
  ] }
}

{
  "amountIn":  { "decimal": "1", "raw": "1000000000000000000" },
  "quotedOut": { "decimal": "393.050819389347166062", "raw": "393050819389347166062" },
  "minOut":    { "decimal": "388.342070573062787012", "raw": "388342070573062787012" },
  "minOutIsEstimate": false,
  "slippageBps": 100,
  "route": { "source": "onedex", "name": "OneDex aggregator",
             "contract": "erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a",
             "reason": "OneDex aggregator (default route)", "pools": ["xExchange", "OneDex"] },
  "priceImpactPct": "0.66",
  "priceCheck": { "aggregatorImpactPct": "0.00", "independentImpactPct": "0.66",
                  "independentSource": "api.multiversx.com" },
  "costs": { "poolFeePct": "0.30", "aggregatorFeePct": "0.20", "networkFeeEgldMax": "—", "…": "…" },
  "costSummary": "You pay 1 EGLD + network fee shown by build_swap_tx; pool fees 0.30% + 0.20% aggregator fee on xExchange hop; price impact 0.66%; you receive at least 388.34207 ONE (expected 393.050819).",
  "warnings": ["Route uses an xExchange pool: minOut includes the aggregator 0.2% xExchange fee taken from the output"],
  "data": { "routeTokens": ["EGLD", "WEGLD-bd4d79", "PROTEO-0c7311", "ONE-f9954f"], "…": "…" }
}

{ "error": { "code": "slippage_needs_confirmation",
             "message": "Slippage 8% is above 5%: pass confirmHighSlippage: true to accept it (max 20%)" } }

{
  "minOut": { "decimal": "388.342070573062787012", "raw": "388342070573062787012" },
  "sender": "erd1…example",
  "transaction": {
    "nonce": 42, "value": "1000000000000000000",
    "receiver": "erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a",
    "sender": "erd1…example",
    "gasPrice": 1000000000, "gasLimit": 77000000,
    "data": "c3dhcEBAMDEwMTAwMDAw…", "chainID": "1", "version": 2, "options": 0
  },
  "costs": { "networkFeeEgldEstimated": "0.00068580472", "networkFeeEgldMax": "0.077", "…": "…" },
  "costSummary": "You pay 1 EGLD + ~0.000686 EGLD network fee (max 0.077, unused gas refunded); pool fees 0.30% + 0.20% aggregator fee on xExchange hop; price impact 0.66%; you receive at least 388.34207 ONE (expected 393.050819).",
  "summary": "Swap 1 EGLD for at least 388.342070573062787012 ONE (quoted 393.050819389347166062, slippage 1%) via OneDex aggregator contract erd1qqqq…6jtsggjx9a on mainnet. …",
  "quotedAt": "2026-11-15T06:32:01.357Z",
  "expiresAt": "2026-11-15T06:34:01.357Z",
  "signingLink": "https://wallet.multiversx.com/hook/transaction?receiver=erd1qqqq…6jtsggjx9a&value=1000000000000000000&gasLimit=77000000&data=swap%40%40…",
  "signing": "UNSIGNED. Sign with your own wallet (this server never sees keys) and check that nonce matches the account nonce. …"
}

{
  "status": "success",
  "failReason": "—",
  "estimatedGasUnits": 34375972,
  "estimatedFeeEgld": "0.00068580472",
  "maxFeeEgld": "0.077",
  "verified": { "route": "OneDex aggregator", "tokenIn": "EGLD", "tokenOut": "ONE-f9954f",
                "minOut": { "decimal": "388.342070573062787012", "raw": "388342070573062787012" } },
  "expectedReceived": { "decimal": "391.480966086456164589", "raw": "391480966086456164589" },
  "meetsMinOut": true,
  "disclaimer": "Simulation does not guarantee execution: prices, balances and nonce can change before your signed transaction is processed. minOut in the transaction is the on-chain protection."
}

{
  "status": "success",
  "finality": "final",
  "feePaidEgld": "0.00064751",
  "feePaidUsd": "0.0017",
  "gasUsed": 50000000,
  "receiver": "erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a",
  "function": "swap",
  "timestamp": "2026-11-15T00:00:00.000Z",
  "data": { "received": [ { "token": "ONE-f9954f", "ticker": "ONE",
                            "decimal": "50", "raw": "50000000000000000000" } ] },
  "explorerUrl": "https://explorer.multiversx.com/transactions/0f3a…example…9c1d"
}

Error codes

What to do for each code, and which ones are safe to retry: Errors & recovery.

Errors and recovery

A tool error is a tool result with isError: true whose text is { "error": { "code": "…", "message": "…" } }. Decide on error.code; show error.message to the user when it helps. Also as plain Markdown: errors.md.

Other failures (no error code)

Rate limits

Per client IP, fixed one-minute windows, counted by each server instance (full detail in Limits). Hosted connectors (Claude.ai, ChatGPT) call from the vendor's shared IPs, so rate_limited is more likely there.

Safety

• Non-custodial. The server returns unsigned transactions only. It never receives, stores or asks for private keys or seed phrases, and never signs or broadcasts.
• Slippage. Default 1% (100 bps). Above 5% requires confirmHighSlippage: true. Above 20% is refused.
• minOut enforced on-chain. The minimum is encoded in the transaction; the contract refuses to deliver less. If the market moves below it, the transaction fails instead: no swap happens, and the network fee is still paid. minOut is always above zero and at most the quoted output.
• Receiver allowlist. The receiver is hard-coded: the OneDex aggregator contract erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a, or the allowlisted XOXNO router. Never taken from an API response.
• Rebuilt from verified fields. Every hop, token, amount and xExchange pair is verified (pairs against the official MultiversX API), then the transaction is rebuilt and compared byte-for-byte. Gas limit at most 600M, gas price 1e9, chain ID 1. Guardian, relayer and any extra API field are dropped.
• Wallets with a Guardian (2FA). Transactions come without guardian fields. For a guarded wallet, the one allowed change is, after all checks: set options to 2, add guardian, sign, and add guardianSignature from the guardian / co-signer service; everything else stays unchanged. xPortal and the Web Wallet (and signingLink) do this in their own 2FA flow. Follow the MultiversX Guardian docs. Without it the network refuses the transaction; nothing is moved.
• Risk confirmations belong to the user. confirmHighSlippage and confirmHighImpact are plain flags. An agent should only set them after showing the user the warnings and getting an explicit yes, never on its own.
• Independent price check. Price impact is cross-checked with USD prices from api.multiversx.com. Impact above 10%, or a disagreement above 5 points, requires confirmHighImpact: true.
• XOXNO only when clearly better. XOXNO is used only if its net output is at least 1% better (or OneDex has no route), and only after its full route is decoded and every pool is verified as an active xExchange pair. Otherwise the OneDex route is used.
• Sanitized upstream data. Token names, route hops and received tokens are validated and placed under data. Upstream error text never reaches tool output.
• Simulation does not guarantee execution. Prices, balances and nonce can change before your signed transaction is processed.
• Always verify in your wallet before signing: receiver, amount, token and the minimum received.

Limits

Limits are counted per client IP by each server instance. Hosted connectors (Claude.ai, ChatGPT) call from the vendor's shared IPs, so rate_limited is more likely there than from your own client.

Keys never touch OneDex

The OneDex MCP server only returns quotes and unsigned transactions. It never receives, stores or asks for private keys or seed phrases, and it never signs or broadcasts. Signing always happens in a wallet you control, outside this server.

Before signing, check in the wallet

• Receiver is the OneDex aggregator contract erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a (or the allowlisted XOXNO router).
• Amount and token match what the user asked for (value and data, see the layout below).
• Minimum received matches minOut from build_swap_tx (fresh, for the exact amount). If it is lower than what the user approved at quote time, show it and ask again.
• Nonce is present and matches the account nonce.
• Simulation returned status: "success" and meetsMinOut: true.
• The transaction is not past expiresAt and its fields are unedited (except the Guardian fields of a guarded wallet). Otherwise, quote and build again.

Transaction data layout

data is base64; decoded, it is @-separated. Token identifiers are hex of their UTF-8 text; amounts are big-endian hex, even length. Use integers (BigInt) only, never floats.

• OneDex: where tokenOut and the minimum sit. <unwrap> is empty, or 01 when tokenOut is EGLD (the route then ends in WEGLD-bd4d79). Each <op> is hex: dex type (1 byte, 00 OneDex, 01 xExchange), pair (00, or 01 + 32-byte pair address), operation (00 = fixed input), then a 4-byte length + the token wanted, then a 4-byte length + the amount wanted. The last <op> carries tokenOut and the route minimum. minOut.raw equals that minimum, or that minimum × 0.998 (rounded down) when the route has an xExchange hop, so the encoded minimum is never below minOut.raw.
• XOXNO: where tokenOut and the minimum sit. <minOut> (first argument after xo) equals minOut.raw. <output> 00 = pays out the first token of the table (tokenOut); fe = pays out native EGLD (tokenOut EGLD).

Sign in one click (signingLink)

build_swap_tx also returns signingLink: a MultiversX Web Wallet link (https://wallet.multiversx.com/hook/transaction?receiver=…&value=…&gasLimit=…&data=…, the official send-transaction hook) that opens the wallet with this exact transaction pre-filled. It is built only from the verified transaction, and its receiver is always the OneDex aggregator or the allowlisted XOXNO router. A person opens it, logs in with the sender address, checks the receiver, amount and token on the wallet screen, and confirms there. The wallet sets the nonce and fee and broadcasts. OneDex never sees the signature or the key. signingLink is null when the transaction data is too long for a wallet URL. Pass on a link only if it starts with https://wallet.multiversx.com/hook/transaction?, and tell the person to log in with the sender address.

Autonomous agents (own wallet)

An autonomous agent swaps without a person approving each transaction: it signs with its own wallet. The key belongs to you, the developer, and stays in your environment (a keystore file and a password in environment variables, or your secret manager). It is never sent to OneDex, to the MCP server or to an AI chat. The model only decides what to swap; your code signs.

• Use a dedicated wallet with small funds, used only by the agent. Top it up as needed; never point an agent at your main wallet.
• Consider a Guardian (2FA) on that wallet. A guarded account needs the guardian co-signature: the one allowed change before signing is options: 2 + guardian, then guardianSignature (see the example and the MultiversX Guardian docs).
• Hard-code your own limits: allowed tokens, a maximum amount per swap and per day, a maximum slippage. Check every transaction against them before signing.

Before going live

• Dedicated wallet, small budget. Used only by the agent, funded with what you can afford to lose. Top it up as needed.
• Keys only in a secrets manager or environment variables. Never in a prompt, a tool argument, source code or git.
• Hard limits in the agent's code, not in the prompt: max amount per trade, allowed tokens, max slippage, daily cap.
• Mandatory simulation. Sign only when simulate_swap_tx returns status: "success" and meetsMinOut: true.
• Receiver allowlist. Sign only transactions whose receiver is the OneDex aggregator or the allowlisted XOXNO router.
• Logging. Log every quote, built transaction, simulation, hash and tx_status result. Never log keys or passwords.
• Test with tiny amounts first, and check each result on the explorer.
• Guardian recommended. A Guardian (2FA) on the agent wallet adds a co-signature: set options: 2 + guardian after all checks, sign, add guardianSignature from the co-signer; nothing else changes.

Flow: build_swap_tx over MCP JSON-RPC (plain fetch, no session needed) → check the transaction → simulate_swap_tx → sign locally with @multiversx/sdk-core → broadcast to the MultiversX gateway → poll tx_status.

// EXAMPLE ONLY: review and adapt before using with real funds.
// Node 20+, ES module (agent.mts or "type": "module"), npm i @multiversx/sdk-core
import { Account, Transaction } from '@multiversx/sdk-core'; // + TransactionComputer for a Guardian

const MCP = 'https://aggregator.onedex.app/ai/mcp';
const GATEWAY = 'https://gateway.multiversx.com';
// Contracts build_swap_tx may target (OneDex aggregator, allowlisted XOXNO router)
const ONEDEX = 'erd1qqqqqqqqqqqqqpgqn7wy983tdh5katf5yn5nl2gcdflf4azh6jtsggjx9a';
const ALLOWED = new Set([ONEDEX, 'erd1qqqqqqqqqqqqqpgq5rf2sppxk2xu4m0pkmugw2es4gak3rgjah0sxvajva']);
// YOUR limit, no default: smallest acceptable ONE output, in base units (18 decimals), from env AGENT_MIN_OUT_RAW
const MIN_OUT_RAW = /^\d+$/.test(process.env.AGENT_MIN_OUT_RAW ?? '') ? BigInt(process.env.AGENT_MIN_OUT_RAW!) : null;
if (MIN_OUT_RAW === null) throw new Error('set MIN_OUT_RAW (env AGENT_MIN_OUT_RAW) before running');

// The key stays in YOUR environment: an encrypted keystore file + its password from env vars.
// Never paste a key, seed phrase or keystore into an AI chat or send it to any server.
const account = Account.newFromKeystore(process.env.AGENT_KEYSTORE_PATH!, process.env.AGENT_KEYSTORE_PASSWORD!);
const sender = account.address.toBech32();

let id = 0;
async function call(name: string, args: Record<string, unknown>): Promise<any> {
  const res = await fetch(MCP, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' },
    body: JSON.stringify({ jsonrpc: '2.0', id: ++id, method: 'tools/call', params: { name, arguments: args } })
  });
  const { result, error } = await res.json();
  if (error || result.isError) throw new Error(name + ' failed: ' + (error?.message ?? result.content[0].text));
  return result.structuredContent;
}

// 1. Build the unsigned transaction (small amount, explicit slippage)
const built = await call('build_swap_tx', { tokenIn: 'EGLD', tokenOut: 'ONE-f9954f', amountIn: '0.1', slippageBps: 100, sender });
console.log(built.costSummary, built.warnings);

// 2. Check it yourself before signing
const t = built.transaction;
const acct = await fetch(GATEWAY + '/address/' + sender).then((r) => r.json());
if (!ALLOWED.has(t.receiver) || t.sender !== sender || t.chainID !== '1') throw new Error('unexpected transaction');
if (t.nonce === undefined) throw new Error('no nonce: do not sign, build again shortly');
if (t.nonce !== acct.data?.account?.nonce) throw new Error('nonce does not match the account');
if (BigInt(t.value) !== 100_000_000_000_000_000n) throw new Error('unexpected EGLD value'); // 0.1 EGLD in base units
if (t.gasPrice !== 1_000_000_000 || !(t.gasLimit > 0 && t.gasLimit <= 600_000_000) || t.version !== 2 || (t.options ?? 0) !== 0) throw new Error('unexpected gas or options');
if (built.data?.tokenOut?.id !== 'ONE-f9954f') throw new Error('unexpected output token');
if (BigInt(built.minOut.raw) < MIN_OUT_RAW) throw new Error('minOut below your limit: re-quote / ask'); // your own limit

// 2b. Decode data: function, output token and encoded minimum (BigInt only, no floats)
const parts = Buffer.from(t.data, 'base64').toString('utf8').split('@');
const big = (h: string) => (h === '' ? 0n : BigInt('0x' + h));
const text = (h: string) => Buffer.from(h, 'hex').toString('utf8');
let outToken: string, encodedMin: bigint;
if (t.receiver === ONEDEX) {
  // EGLD in: swap@<unwrap>@<op>…  (ESDT in would be ESDTTransfer@<token>@<amount>@73776170@<unwrap>@<op>…)
  if (parts[0] !== 'swap' || parts[1] !== '' || parts.length < 3) throw new Error('unexpected contract function');
  const op = parts[parts.length - 1]; // last op: final token + route minimum
  let i = 0;
  const take = (n: number) => { const h = op.slice(i, i + 2 * n); if (h.length !== 2 * n) throw new Error('bad route'); i += 2 * n; return h; };
  take(1); // dex type
  const pair = take(1); if (pair === '01') take(32); else if (pair !== '00') throw new Error('bad route');
  if (take(1) !== '00') throw new Error('not a fixed-input swap');
  outToken = text(take(Number(big(take(4)))));
  encodedMin = big(take(Number(big(take(4)))));
  if (i !== op.length) throw new Error('bad route');
} else {
  // XOXNO, EGLD in: xo@<minOut>@<output>@<referral>@<nT>@<token0>…  (output 00 = pays token0)
  if (parts[0] !== 'xo' || parts[2] !== '00') throw new Error('unexpected contract function');
  encodedMin = big(parts[1]);
  outToken = text(parts[5]);
}
if (outToken !== 'ONE-f9954f') throw new Error('data does not pay out the expected token');
if (encodedMin < BigInt(built.minOut.raw)) throw new Error('encoded minimum is below minOut');

// 3. Simulate (no signature needed)
const sim = await call('simulate_swap_tx', { transaction: t, minOut: built.minOut.raw, tokenIn: 'EGLD', tokenOut: 'ONE-f9954f', amountIn: '0.1' });
// Required. Autonomous rule: stop unless status is success AND meetsMinOut is true ("—" also stops).
if (sim.status !== 'success' || sim.meetsMinOut !== true) throw new Error('simulation failed: ' + sim.failReason);

// 4. Sign locally and broadcast to the MultiversX gateway (OneDex is not involved)
// Rebuild from the checked fields only: nothing else the server sent gets signed.
const tx = Transaction.newFromPlainObject({
  nonce: t.nonce, value: t.value, receiver: t.receiver, sender: t.sender, gasPrice: t.gasPrice,
  gasLimit: t.gasLimit, data: t.data, chainID: t.chainID, version: t.version, options: 0
});
// Guarded wallet (Guardian / 2FA) only: the ONE allowed change, after all checks above.
//   new TransactionComputer().applyGuardian(tx, guardianAddress); // sets options to 2 and guardian
//   ...sign as below, then set tx.guardianSignature from your guardian / co-signer service.
// Everything else stays unchanged. Follow the MultiversX Guardian docs: https://docs.multiversx.com
tx.signature = await account.signTransaction(tx);
let sent: any;
try {
  sent = await fetch(GATEWAY + '/transaction/send', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(tx.toPlainObject())
  }).then((r) => r.json());
} catch {
  // Unknown outcome: check tx_status (hash of THIS signed tx) and the account nonce; never sign a new tx.
  // Re-sending the SAME signed tx is harmless (same nonce); signing a NEW one is the danger.
  throw new Error('broadcast response lost: unknown outcome');
}
const hash: string = sent.data?.txHash;
if (!hash) throw new Error('broadcast failed: ' + sent.error);

// 5. Poll tx_status: done on success / fail; "final" only when finality is final
let st: any = null;
for (let i = 0; i < 30; i++) { // about 90 s
  await new Promise((r) => setTimeout(r, 3000));
  st = await call('tx_status', { hash });
  if (st.status === 'success' || st.status === 'fail') break;
}
if (st?.status === 'success') console.log(st.finality === 'final' ? 'swap final' : 'swap succeeded, not final yet', st.data.received);
else if (st?.status === 'fail') console.log('swap failed', st);
else console.log('unknown outcome after 90 s: keep checking tx_status and the nonce; never sign a new tx for this swap');

Account.newFromKeystore, Account.newFromPem (development only) and UserSigner are all in @multiversx/sdk-core; the separate sdk-wallet package is no longer needed. See the MultiversX SDK cookbook.

Frequently asked

Discover the server

Agents do not need this page to use the server: after initialize, the server returns its own instructions, and tools/list returns all six tools with their JSON input schemas.