Dokumentation
Mit nodexch entwickeln
Alles, was eine erste Integration braucht, in der Reihenfolge, in der du es brauchst. Jede Route und ihre Felder stehen in der API-Referenz.
Schnellstart
nodexch spricht die Coinset-API: jede Methode ist POST /<method> auf https://api.nodexch.com mit einem JSON-Body, und die Antwort des Node kommt Byte für Byte zurück. Ein Coinset-Client ändert seine Basis-URL und fügt einen Schlüssel hinzu.
Jedes Beispiel liest das Gateway aus NODEXCH_URL und deinen Schlüssel aus NODEXCH_KEY. Sie laufen vor jedem Release gegen ein echtes Gateway, funktionieren also wie geschrieben.
#!/bin/sh
# The health check needs no key; every Coinset method is POST /<method> with a JSON body.
set -eu
url="${NODEXCH_URL:-https://api.nodexch.com}"
curl -fsS "$url/health"
echo
curl -fsS "$url/get_blockchain_state" \
-H "Authorization: Bearer $NODEXCH_KEY" \
-d '{}'
echo// The chain's peak through the typed client: every path and body is checked by TypeScript.
import { createNodexch } from "../../clients/typescript/src/index.ts";
const nodexch = createNodexch({
baseUrl: process.env.NODEXCH_URL ?? "https://api.nodexch.com",
key: process.env.NODEXCH_KEY,
});
const { data, error, response } = await nodexch.POST("/get_blockchain_state", { body: {} });
if (error || !data || data.success !== true) {
throw new Error(`get_blockchain_state answered ${response.status}: ${JSON.stringify(error ?? data)}`);
}
// The node's fields, described in the API reference; the spec types them as open objects.
const state = data.blockchain_state as { peak: { height: number }; sync: { synced: boolean } };
console.log(`peak ${state.peak.height}, synced: ${state.sync.synced}`);//! The chain's peak with reqwest: every Coinset method is `POST /<method>` with a JSON body.
//! (`cargo run --example first_call` from gateway/; in your own crate: reqwest with the `json`
//! feature, tokio and serde_json.)
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let url = std::env::var("NODEXCH_URL").unwrap_or_else(|_| "https://api.nodexch.com".into());
let key = std::env::var("NODEXCH_KEY")?;
let state: serde_json::Value = reqwest::Client::new()
.post(format!("{url}/get_blockchain_state"))
.bearer_auth(key)
.json(&serde_json::json!({}))
.send()
.await?
.error_for_status()?
.json()
.await?;
if state["success"] != true {
return Err(format!("the gateway said: {}", state["error"]).into());
}
let peak = &state["blockchain_state"]["peak"]["height"];
let synced = &state["blockchain_state"]["sync"]["synced"];
println!("peak {peak}, synced: {synced}");
Ok(())
}Das TypeScript-Beispiel nutzt den typisierten Client, der aus dem OpenAPI-Dokument der API erzeugt wird: jeder Pfad und jeder Request-Body wird vom Compiler geprüft. /openapi.json ist dasselbe Dokument für jeden anderen Generator.
Ganzzahlen jenseits von 253 (Netspace, große Beträge) kommen genau so an, wie der Node sie schreibt, und JSON.parse rundet sie stillschweigend: parse solche Antworten mit einem Parser, der große Ganzzahlen kennt, wo der genaue Wert zählt; Event-Frames schreiben sie als Strings.
Was du abfragen kannst
nodexch beantwortet die Methoden von Coinset und ergänzt eigene Kanäle unter /x/…. Das sind die Familien, jede mit einigen ihrer Routen; alle, mit jedem Feld, stehen in der API-Referenz.
- Blöcke
- Blöcke, Block-Records, ihre Spends und die Coins, die sie hinzufügen und entfernen.
/get_block_record_by_height/get_blocks/get_block_spends/get_additions_and_removals - Coins
- Coin-Records nach Name, Puzzle-Hash, Parent oder Hint; Puzzles und Solutions.
/get_coin_record_by_name/get_coin_records_by_puzzle_hash/get_coin_records_by_hint/get_puzzle_and_solution - Transaktionen
- Transaktionen mit Coinsets Zusammenfassung dessen, was sie getan haben, und Reorgs.
/get_transaction/get_transactions_by_p2/get_pending_transactions_by_p2/get_reorgs - Adressen, Token und NFTs
- Was eine Adresse hält: XCH, CAT-Token, NFTs und Singletons.
/get_xch_balance_by_p2/get_cat_balances_by_p2/get_nft_ids_by_p2/get_singleton_info - Mempool und Gebühren
- Was im Mempool wartet, was ein Spend jetzt kostet, und das Einreichen eines Spends.
/get_all_mempool_items/get_mempool_item_by_tx_id/get_fee_estimate/push_tx - Angebote
- Angebote nach ID, Token, NFT oder Adresse, ihr Status und der Handelsverlauf.
/get_offer/get_offers_by_cat_asset_id/push_offer/x/offers/v1/trades - Die eigenen Kanäle von nodexch
- Die Nodes des Netzwerks, Mempool und Gebühren in Bändern, Token-Namen und -Icons, der XCH-Preis.
/x/node/v1/network/x/node/v1/mempool/x/node/v1/fees/x/assets/v1/assets/x/price/v1/xch - Live-Events
- Dieselbe Chain als Stream: ein WebSocket oder Server-Sent Events.
/ws/events
Schlüssel
Sende einen Schlüssel als Authorization: Bearer <key>. Ohne ihn antworten nur die Proben (/up, /ready, /health), das OpenAPI-Dokument (/openapi.json) und diese Website.
- Geheime Schlüssel (
nxs_…) sind für Server. Setze nie einen in eine Webseite, ein App-Bundle oder eine URL. - Öffentliche Schlüssel (
nxp_…) sind für Browser. Sie funktionieren nur von den Origins, für die sie ausgegeben wurden, bekommen von der Adresse eines Besuchers nicht mehr als ein Besucher ohne Schlüssel und öffnen nie die Betreiber-Routen. - Browser können auf einem WebSocket oder einer
EventSourcekeine Header setzen, daher nehmen/wsund/eventseinen öffentlichen Schlüssel auch als?key=. Ein geheimer Schlüssel in einer URL wird abgelehnt. - Ein durchgesickerter Schlüssel wird rotiert: der neue gilt sofort, der alte endet sofort. Halte den neuen also für das Deployment bereit, wenn du rotierst.
Limits
Der Tarif eines Schlüssels legt eine Rate pro Minute, ein Kontingent pro Monat und eine Zahl offener Streams fest. Jede Antwort mit Schlüssel sagt, wo du stehst:
| Header | Bedeutung |
|---|---|
x-ratelimit-limit, x-ratelimit-remaining | Anfragen in dieser Minute |
x-quota-limit, x-quota-remaining | Anfragen in diesem Monat |
retry-after | Bei 429 oder 503: Sekunden, bis der nächste Versuch gelingen kann |
x-nodexch-tier | Woher die Antwort kam: eine Cache-Stufe (immutable, peak, state, mempool), none, index, passthrough oder stream |
ETag | Schick ihn als If-None-Match zurück und bekomm ein 304, solange sich nichts geändert hat |
Antworten, über die die Chain nicht hinweggegangen ist, kommen aus dem Cache, Polling ist also günstig; die Live-Events unten sind noch günstiger.
Tarife und Kontingent
Wie ein Tarif bezahlt wird, was er gibt und was an seinen Rändern passiert. Die Kontoseite zeigt alles für dein Konto.
- Jeder Tarif wird monatlich oder jährlich verkauft; der Jahrespreis ist zwölf Monate abzüglich der Ersparnis, die die Preisseite zeigt. Chia kennt keine Lastschrift, daher ist jeder Zeitraum eine Rechnung, die du auf der Kontoseite in XCH bezahlst: mit Sage in einem Klick oder mit einem Chia-Vault über Adresse, Betrag und Memo. Die Rechnung für die Verlängerung entsteht 7 Tage vor Ende des Zeitraums, und eine Mail erinnert dich, wenn du eine Adresse angegeben hast.
- Dein Kontingent gibt es einmal pro Konto, geteilt von allen Schlüsseln. Es läuft vom Tag deines Abos bis zum selben Tag des nächsten Monats, auch bei einem Jahrestarif (es wird monatlich gewährt). Ungenutzte Anfragen werden nicht übertragen. Die Kontoseite zeigt, was übrig ist und wann es neu beginnt, in UTC.
- Bei null antworten Anfragen mit 429 quota_exceeded, einem retry-after-Header sowie x-quota-reset und resets_at im Body: dem Zeitpunkt, an dem das Kontingent neu beginnt. Jede Antwort trägt x-quota-limit, x-quota-remaining und x-quota-reset. Es gibt kein Nachkaufen: ein Upgrade beginnt heute einen neuen Zeitraum mit vollem Kontingent.
- Ein Upgrade wird jetzt voll bezahlt und beginnt an diesem Tag einen neuen Zeitraum; der Rest des alten wird nicht angerechnet. Ein Downgrade und eine Kündigung gelten zum Ende des bezahlten Zeitraums. Es gibt keine Erstattung: der bezahlte Zeitraum läuft aus.
- Wird eine Verlängerung nicht bezahlt, folgen auf das Ende des Zeitraums 7 Tage Nachfrist. Dann sind Konto und Schlüssel im kostenlosen Tarif: nie gesperrt, nur mit den Gratis-Limits. Eine spätere Zahlung beginnt an diesem Tag einen neuen Zeitraum.
- Eine E-Mail-Adresse ist optional, ein bezahlter Tarif braucht aber eine bestätigte: Erinnerungen und Sicherheitshinweise gehen dorthin. Sie ist nie ein Weg zur Anmeldung. Verlierst du alle Passkeys, registriert ein an sie gesendeter Link einen neuen Passkey, der 24 Stunden später anmeldet; ein Passkey, den du noch hast, kann das vorher abbrechen. Ohne Adresse lässt sich ein verlorener Passkey nicht wiederherstellen.
Fehler
Die eigenen Fehler von nodexch sind JSON mit einem HTTP-Status und einem stabilen Code:
{"success": false, "error": "an API key is required: send Authorization: Bearer <key>", "code": "unauthorized"}Eine Ablehnung durch den Node selbst behält dagegen die Form von Coinset: HTTP 200 mit success: false und error (etwa ein Block, den es nicht gibt). Prüfe success in jeder Antwort.
| Status | Code | Wann |
|---|---|---|
| 400 | bad_request, validation_failed | Der Body ist kein JSON, oder ein Feld fehlt oder ist fehlerhaft; der Fehler nennt das Feld. |
| 401 | unauthorized | Kein Schlüssel, oder einer, den das Gateway nicht kennt oder der widerrufen wurde. |
| 401 | key_expired | Der Tarif des Schlüssels ist über sein Bezahlt-bis-Datum hinaus. |
| 403 | forbidden | Der Schlüssel darf diese Route nicht nutzen: ein öffentlicher Schlüssel auf einer Betreiber-Route, oder von einem Origin, für den er nicht ausgegeben wurde. |
| 404 | not_found | Keine solche Route oder Methode. |
| 429 | rate_limited, quota_exceeded | Über der Rate pro Minute oder dem Monatskontingent; warte retry-after Sekunden. |
| 501 | not_enabled | Dieses Deployment bedient diese Familie von Methoden nicht („index not enabled“). |
| 502 | upstream_failed | Der Node oder der Upstream hat nicht geantwortet. |
| 503 | unavailable | Startet gerade oder ohne Budget; retry-after sagt, wann ein neuer Versuch lohnt. |
Paging
Die Coinset-Methoden blättern wie bei Coinset: Höhenbereiche mit start und end (end nicht eingeschlossen, höchstens 1.000 Blöcke auf einmal).
Die eigenen Listen von nodexch unter /x/… nehmen limit und cursor. Jede Seite trägt next_cursor; gib ihn als cursor für die nächste Seite mit, bis er null ist.
curl -s "https://api.nodexch.com/x/offers/v1/trades?asset_id=xch&limit=100" \
-H "Authorization: Bearer $NODEXCH_KEY"
curl -s "https://api.nodexch.com/x/offers/v1/trades?asset_id=xch&limit=100&cursor=<next_cursor>" \
-H "Authorization: Bearer $NODEXCH_KEY"Live-Events
Ein WebSocket, /ws?events=peak,transaction,reorg,dashboard, oder dieselben Frames als Server-Sent Events auf /events. Ohne events bekommt ein Stream die vier Typen von Coinset; offer ist der eigene von nodexch und kommt nur auf Wunsch.
Jeder Frame ist {"network", "seq", "message": {"type", "data"}}. seq zählt jeden Frame, den das Gateway sendet, ein Stream mit weniger Typen sieht also Lücken; das sind keine verlorenen Frames.
// The live events: open /ws, wait for the next peak, close. Frames are
// {"network","seq","message":{"type","data"}}, as Coinset sends them.
import { eventsUrl } from "../../clients/typescript/src/index.ts";
const base = process.env.NODEXCH_URL ?? "https://api.nodexch.com";
// Browsers put a publishable key in the URL; a server may send its secret key as a header instead.
const socket = new WebSocket(eventsUrl(base, ["peak"], process.env.NODEXCH_PUBLISHABLE_KEY));
let done = false;
const timeout = setTimeout(() => {
console.error("no peak within 60 s");
process.exit(1);
}, 60_000);
socket.addEventListener("message", (event) => {
const frame = JSON.parse(String(event.data));
if (frame.message?.type === "peak") {
console.log(`peak ${frame.message.data.height} on ${frame.network} (seq ${frame.seq})`);
done = true;
clearTimeout(timeout);
socket.close();
}
});
socket.addEventListener("error", () => {
if (done) return;
console.error("the stream failed");
process.exit(1);
});peakEin neuer Peak;
txsagt, ob es ein Transaktionsblock ist.Beispiel-Frame
{ "network": "mainnet", "seq": 1, "message": { "type": "peak", "data": { "height": 8412345, "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "tx": true, "timestamp": 1790480000 } } }transactionMempool-IDs in Stapeln:
pendingbeim Eintreffen,confirmedmit dem Block, der sie aufnahm,removed, wenn sie ohne einen verschwanden.Beispiel-Frames (3)
{ "network": "mainnet", "seq": 2, "message": { "type": "transaction", "data": { "ids": [ "0x7777777777777777777777777777777777777777777777777777777777777777" ], "status": "pending", "height": null } } }{ "network": "mainnet", "seq": 3, "message": { "type": "transaction", "data": { "ids": [ "0x7777777777777777777777777777777777777777777777777777777777777777" ], "status": "confirmed", "height": 8412346 } } }{ "network": "mainnet", "seq": 4, "message": { "type": "transaction", "data": { "ids": [ "0x8888888888888888888888888888888888888888888888888888888888888888" ], "status": "removed", "height": null } } }reorgDer Peak ist auf einen anderen Zweig gewechselt; alles, was bei den alten Höhen gelesen wurde, kann sich geändert haben.
Beispiel-Frame
{ "network": "mainnet", "seq": 5, "message": { "type": "reorg", "data": { "old_peak_height": 8412346, "old_peak_hash": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "new_peak_height": 8412346, "new_peak_hash": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", "reorg_depth": 1, "detected_at_ms": 1790480031250 } } }dashboardDer Feed, den die Startseite eines Explorers braucht, ein
kindnach dem anderen.Beispiel-Frames (4)
{ "network": "mainnet", "seq": 6, "message": { "type": "dashboard", "data": { "kind": "mempool_delta", "added": [ { "id": "0x7777777777777777777777777777777777777777777777777777777777777777", "first_seen_ms": 1790480012000, "fee_mojos": 50000000, "cost": 12000000, "spends": 2, "additions": [ { "parent_coin_info": "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", "puzzle_hash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "amount": 1000 } ], "removals": [ { "parent_coin_info": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "puzzle_hash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "amount": 1000 } ], "addition_count": 3, "removal_count": 2, "kind": "cat", "asset_ids": [ "0x9999999999999999999999999999999999999999999999999999999999999999" ], "assets": { "xch": "50000000", "cats": [ { "asset_id": "0x9999999999999999999999999999999999999999999999999999999999999999", "amount": "1000" } ], "nfts": 0, "dids": 0, "singletons": 0 } } ], "removed": [ "0x8888888888888888888888888888888888888888888888888888888888888888" ] } } }{ "network": "mainnet", "seq": 7, "message": { "type": "dashboard", "data": { "kind": "live", "peak_height": 8412345, "mempool_size": 236, "mempool_cost": 88500547228, "mempool_fees": 350012, "synced": true } } }{ "network": "mainnet", "seq": 8, "message": { "type": "dashboard", "data": { "kind": "block", "height": 8412345, "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "timestamp": 1790480000, "fees": 350012, "additions": 42, "removals": 17, "record": { "height": 8412345, "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "timestamp": 1790480000, "fees": 350012, "weight": 36893488147419103000 }, "spends": 17, "assets": { "xch": "12209542198803", "cats": [ { "asset_id": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", "amount": "3938" } ], "nfts": 1, "dids": 0, "singletons": 2 } } } }{ "network": "mainnet", "seq": 10, "message": { "type": "dashboard", "data": { "kind": "netspace", "bytes": "16487192343748823040000", "difficulty": 2384, "height": 8412345 } } }offerEine neue Offer aus dem Splash-Netzwerk, mit den Offer-Feldern von Coinset und der Offer-Datei, mit der man sie annimmt (hier gekürzt).
Beispiel-Frame
{ "network": "mainnet", "seq": 10, "message": { "type": "offer", "data": { "offer_id": "8b239d3813a72e10cec3efa6b05841017cef2828add97026cd8352a53378e4da", "status": "open", "first_seen_ms": 1790480012000, "last_updated_ms": 1790480012000, "maker_p2s": [ "d8b1e0d9a0e46b3403dff2f6c27fc46bc13e6f5ee5ff09dc28d28d28d51be422" ], "offered_cat_asset_ids": [ "ec25b77bc54df637392d6a0f542de65f45020405d0f36ced723bff2870c378b1" ], "requested_cat_asset_ids": [], "offered_nft_ids": [], "requested_nft_ids": [], "offered_xch_mojos": 0, "requested_xch_mojos": 500003000000, "offered_cat_mojos": { "ec25b77bc54df637392d6a0f542de65f45020405d0f36ced723bff2870c378b1": 1000 }, "fee_mojos": 0, "pending_p2s": [], "offer": "offer1qqr83wcuu2rykcmqvpsxygqqemhmlaekcenaz02ma6hs5w600dhjlv…", "source": "splash", "network": "mainnet" } } }
Agenten (MCP)
KI-Agenten lesen nodexch über seinen MCP-Server unter https://api.nodexch.com/mcp: das Orderbuch eines Paars, das günstigste Angebot zuerst, ein Angebot mit seinem Text, das Dekodieren eines Angebots, die letzten Trades, das Kreditboard und Preise. Er liest nur, berührt nie eine Wallet, und jeder Tool-Aufruf wird in Credits auf deinem geheimen Schlüssel abgerechnet, wie die Routen, die er nutzt.
Claude Code
Erstelle auf der Agenten-Seite einen Schlüssel für den Agenten, der dort gleich in diesen Befehl eingesetzt wird, und füge den Server einmal hinzu. Claude Code speichert den Schlüssel in seinen Einstellungen; in der .mcp.json eines Projekts schreibst du stattdessen "NODEXCH_KEY": "${NODEXCH_KEY}" in die env des Servers, dann kommt er aus der Umgebung.
#!/bin/sh
# Connects Claude Code to nodexch in one install (@nodexch/mcp, TASK-176.04): the offer book,
# offers, trades, the loan board and prices, publishing an offer, metered in credits on your secret
# API key (nodexch.com, Account); and the Xchonnect wallet tools, run on your computer, which ask
# your wallet to take, make or cancel offers (nodexch never sees those requests).
#
# --scope user: every project of yours; the key is stored in ~/.claude.json. In a project's
# .mcp.json write "NODEXCH_KEY": "${NODEXCH_KEY}" in its env instead: Claude Code reads it from
# the environment, and the key stays out of the file.
# The key is passed to `claude mcp add` as an argument (-e), visible in the process list while it runs.
set -eu
: "${NODEXCH_KEY:?set NODEXCH_KEY=nxs_...}"
url="${NODEXCH_URL:-https://api.nodexch.com}"
command -v npx >/dev/null 2>&1 || { echo "nodexch: Node.js 22.12 or newer is needed (npx runs @nodexch/mcp)" >&2; exit 1; }
claude mcp add --scope user nodexch -e NODEXCH_KEY="$NODEXCH_KEY" -e NODEXCH_URL="$url" \
-- npx -y @nodexch/mcp
claude mcp listDieselbe Installation bringt die Xchonnect-Wallet-Werkzeuge (@nodexch/mcp führt sie auf deinem Computer aus): Der Agent koppelt sich mit deiner Wallet und bittet sie, Angebote anzunehmen oder zu erstellen, und die Wallet entscheidet innerhalb der Regeln, die du für den Agenten festlegst. Trades laufen nie über nodexch.
Claude im Web, auf dem Desktop und auf dem Handy
Füge https://api.nodexch.com/mcp als benutzerdefinierten Connector hinzu; Claude meldet sich über nodexch mit deinem Passkey an und bekommt einen eigenen Schlüssel, es gibt also nichts zu kopieren. Claude Free erlaubt einen benutzerdefinierten Connector, für das Wallet-Plugin bleibt dann kein Platz: Die Agenten-Seite, Tab Claude, sagt, was das bedeutet und wie du trotzdem handelst.
Im Browser, ohne Plugin
Die Agenten-Seite koppelt sich selbst mit deiner Wallet, für einen Agenten, der in deinem Browser arbeitet, etwa Claude in Chrome. Die Sitzung bleibt verschlüsselt in diesem Browser; nodexch signiert jede Kopplung für dein Konto und kann die Sitzung nicht lesen; sein Relay trägt nur versiegelte Nachrichten. Der Agent und sein Anbieter sehen die Seite. Von dort liest sie die Regeln deiner Wallet, nimmt und erstellt Angebote, stellt Leitern und storniert; das ist langsamer als ein lokales Plugin und noch nicht mit Claude in Chrome erprobt.
Claude Desktop, Cursor und VS Code
Dieselbe Installation in einer Konfigurationsdatei. Setze deinen Schlüssel statt nxs_your_secret_key ein (VS Code fragt danach) oder nimm die Datei von der Agenten-Seite, die ihn einträgt; dort steht auch, wo jede Datei liegt.
{
"mcpServers": {
"nodexch": {
"command": "npx",
"args": ["-y", "@nodexch/mcp"],
"env": {
"NODEXCH_KEY": "nxs_your_secret_key"
}
}
}
}{
"mcpServers": {
"nodexch": {
"command": "npx",
"args": ["-y", "@nodexch/mcp"],
"env": {
"NODEXCH_KEY": "nxs_your_secret_key"
}
}
}
}{
"inputs": [
{
"type": "promptString",
"id": "nodexch-key",
"description": "nodexch secret API key (nxs_…)",
"password": true
}
],
"servers": {
"nodexch": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@nodexch/mcp"],
"env": {
"NODEXCH_KEY": "${input:nodexch-key}"
}
}
}
}Tools
Was jedes Tool tut und was ein Aufruf höchstens kostet: die Gewichte der Routen, die es ausführt, ein Viertel für eine Antwort aus dem Cache, nichts bei einem Fehler. Jedes Ergebnis sagt, was es gekostet hat und was übrig ist.
| Tool | Credits | Was es tut |
|---|---|---|
search_assets | 1 | Findet die Asset-ID eines Tokens nach Ticker oder Name. |
offer_book | 2 | Die offenen Angebote eines Paars, das günstigste zuerst. |
best_offer | 3 | Das günstigste Angebot eines Paars, mit seinem Text zum Annehmen. |
get_offer | 1 | Ein offenes Angebot: Beträge, Preis, Ablauf und sein Text. |
partial_offers | 2 | Partial offers |
get_partial_offer | 1 | Get a partial offer |
decode_offer | 2 | Liest einen Angebotstext: was er gibt, verlangt und kostet. |
post_offer | 5 | Veröffentlicht ein Angebot deiner Wallet im Orderbuch und im Splash-Netzwerk. |
recent_trades | 1 | Angenommene Angebote, die neuesten zuerst. |
loan_board | 1 | Offene Kreditangebote in diesem Netzwerk. |
prices | 2 | XCH in USD und Tokenpreise in XCH. |
Die Protokollnachrichten selbst (initialize, tools/list) kosten nichts. Ein Tarif ohne einen Kanal bekommt einen Tool-Fehler, der einen Tarif mit ihm nennt.
Von Hand
#!/bin/sh
# The MCP server for agents is POST /mcp with a secret key: one JSON-RPC message per request.
# An MCP client (Claude Code) does this for you; here is what it sends.
set -eu
: "${NODEXCH_KEY:?set NODEXCH_KEY=nxs_...}"
url="${NODEXCH_URL:-https://api.nodexch.com}"
mcp() {
curl -fsS "$url/mcp" \
-H "Authorization: Bearer $NODEXCH_KEY" \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
-d "$1"
echo
}
mcp '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
mcp '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'