@ironwallet/mcp-server 1.0.0-preprod.0

package/dist/api/swap.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Swap Proxy (SWP) HTTP client — matches mobile SwapProxyApiClient:
+ *   /swp/refs/*  discovery
+ *   /swp/exchange/*  estimate → create → execute → status
+ *
+ * Auth: IWB Bearer + device headers (same as relay). Not the transfer relay.
+ */
+export interface SwapAsset {
+    network: string;
+    symbol: string;
+    address?: string | null;
+    decimals: number;
+}
+export interface SwapSide {
+    asset: SwapAsset;
+    address: string;
+    amount?: string;
+}
+export interface SwapCallOpts {
+    correlationId?: string;
+}
+export interface SwapApiError {
+    code?: number;
+    reason?: string;
+    traceId?: string;
+    raw?: unknown;
+}
+export declare class SwapError extends Error {
+    readonly code?: number;
+    readonly traceId?: string;
+    readonly raw?: unknown;
+    constructor(message: string, info?: SwapApiError);
+}
+export interface SwapNetworkItem {
+    id?: number;
+    name: string;
+    decimals?: number;
+}
+export declare function listSwapNetworks(token: string, opts?: SwapCallOpts): Promise<SwapNetworkItem[]>;
+export interface SwapAssetsPage {
+    items: SwapAsset[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export declare function listSwapAssetsFrom(token: string, params?: {
+    search?: string;
+    page?: number;
+    pageSize?: number;
+    networks?: string[];
+}, opts?: SwapCallOpts): Promise<SwapAssetsPage>;
+export declare function listSwapAssetsTo(token: string, params: {
+    from: Pick<SwapAsset, "network" | "symbol" | "address">;
+    search?: string;
+    page?: number;
+    pageSize?: number;
+    networks?: string[];
+}, opts?: SwapCallOpts): Promise<SwapAssetsPage>;
+export interface SwapEstimateResult {
+    operationId: string;
+    provider?: string;
+    from: SwapSide & {
+        amount?: string;
+    };
+    to: SwapSide & {
+        amount?: string;
+    };
+    correctedAmountFrom?: string;
+    correctedAmountTo?: string;
+    details?: Record<string, unknown>;
+    raw: Record<string, unknown>;
+}
+export declare function estimateSwap(token: string, params: {
+    from: SwapSide;
+    to: SwapSide;
+    maxMode?: boolean;
+}, opts?: SwapCallOpts): Promise<SwapEstimateResult>;
+export interface SwapTxToSign {
+    txId?: string;
+    txData?: string;
+    extraData?: string;
+    type?: string;
+}
+export interface SwapCreateResult {
+    operationId: string;
+    swapOrderId: string;
+    provider?: string;
+    txsToSign: SwapTxToSign[];
+    raw: Record<string, unknown>;
+}
+export declare function createSwap(token: string, params: {
+    operationId: string;
+    correctedAmountFrom: string;
+    from: SwapSide;
+    to: SwapSide;
+    maxMode?: boolean;
+}, opts?: SwapCallOpts): Promise<SwapCreateResult>;
+export interface SwapSignedTxDto {
+    type: string;
+    signedTx: string;
+    txData: string;
+    txHash: string;
+    txId: string;
+}
+export interface SwapExecuteResult {
+    operationId: string;
+    txHash?: string;
+    raw: Record<string, unknown>;
+}
+export declare function executeSwap(token: string, params: {
+    operationId: string;
+    swapOrderId: string;
+    from: SwapSide;
+    to: SwapSide;
+    signedTransactions: SwapSignedTxDto[];
+}, opts?: SwapCallOpts): Promise<SwapExecuteResult>;
+export declare function getSwapStatus(token: string, operationId: string, opts?: SwapCallOpts): Promise<Record<string, unknown>>;
+/**
+ * Resolve decimals for a short asset ref via SWP catalog.
+ * Sell assets: `/assets/from`. Buy assets: `/assets/to` (needs `from` context).
+ *
+ * Walks catalog pages (not just page 1). Prefer passing `decimals` from
+ * `list_swap_assets` to skip lookup entirely.
+ */
+export declare function resolveSwapAsset(token: string, ref: {
+    network: string;
+    symbol: string;
+    address?: string | null;
+    decimals?: number;
+}, opts?: SwapCallOpts & {
+    /** When resolving a buy-side asset, pass the sell asset for `/assets/to`. */
+    fromForToLookup?: Pick<SwapAsset, "network" | "symbol" | "address">;
+}): Promise<SwapAsset>;
+export declare function assetKey(a: Pick<SwapAsset, "network" | "symbol" | "address">): string;

package/dist/api/swap.js

@@ -0,0 +1,554 @@
+/**
+ * Swap Proxy (SWP) HTTP client — matches mobile SwapProxyApiClient:
+ *   /swp/refs/*  discovery
+ *   /swp/exchange/*  estimate → create → execute → status
+ *
+ * Auth: IWB Bearer + device headers (same as relay). Not the transfer relay.
+ */
+import { getConfig } from "../config.js";
+import { authHeaders } from "./auth.js";
+import { httpJson } from "./http.js";
+import { logError, logInfo, newCorrelationId } from "../log.js";
+export class SwapError extends Error {
+    code;
+    traceId;
+    raw;
+    constructor(message, info = {}) {
+        super(message);
+        this.name = "SwapError";
+        this.code = info.code;
+        this.traceId = info.traceId;
+        this.raw = info.raw;
+    }
+}
+function capitalizeNetwork(name) {
+    const t = name.trim();
+    if (!t)
+        return t;
+    return t.charAt(0).toUpperCase() + t.slice(1).toLowerCase();
+}
+/** SwapKit tickers are uppercase (`USDT`). SWP catalog symbols are not (`usdt`, `USDt`). */
+function canonicalSwapSymbol(symbol) {
+    return symbol.trim().toUpperCase();
+}
+function assetToJson(asset) {
+    const body = {
+        network: asset.network.toLowerCase(),
+        symbol: canonicalSwapSymbol(asset.symbol),
+        decimals: asset.decimals,
+    };
+    if (asset.address)
+        body.address = asset.address;
+    return body;
+}
+function sideToJson(side) {
+    const body = {
+        asset: assetToJson(side.asset),
+        address: side.address,
+    };
+    if (side.amount !== undefined)
+        body.amount = side.amount;
+    return body;
+}
+function parseSwapError(body, fallback) {
+    if (!body)
+        return new SwapError(fallback);
+    try {
+        const json = JSON.parse(body);
+        const errors = json.errors;
+        const first = Array.isArray(errors) && errors[0] && typeof errors[0] === "object"
+            ? errors[0]
+            : json;
+        const codeRaw = first.code ?? json.status;
+        const code = typeof codeRaw === "number"
+            ? codeRaw
+            : typeof codeRaw === "string"
+                ? Number.parseInt(codeRaw, 10)
+                : undefined;
+        const reason = (typeof first.reason === "string" && first.reason) ||
+            (typeof json.title === "string" && json.title) ||
+            fallback;
+        const traceId = typeof json.traceId === "string" ? json.traceId : undefined;
+        const msg = code !== undefined && Number.isFinite(code)
+            ? `Swap API error ${code}: ${reason}`
+            : `Swap API error: ${reason}`;
+        return new SwapError(msg, { code, reason, traceId, raw: json });
+    }
+    catch {
+        return new SwapError(`${fallback}: ${body.slice(0, 300)}`);
+    }
+}
+async function swpJson(path, init, opts) {
+    const cfg = getConfig();
+    const url = `${cfg.swapProxyUrl.replace(/\/$/, "")}${path}`;
+    const correlationId = opts.correlationId ?? newCorrelationId("swp");
+    try {
+        return await httpJson(url, init, {
+            correlationId,
+            label: opts.label,
+            retry: opts.retry,
+            timeoutMs: opts.timeoutMs,
+        });
+    }
+    catch (e) {
+        const err = e;
+        if (err && typeof err.status === "number") {
+            throw parseSwapError(err.body, err.message);
+        }
+        throw e;
+    }
+}
+function assertNoError(json, label) {
+    const errors = json.errors;
+    const hasErrors = Array.isArray(errors)
+        ? errors.length > 0
+        : Boolean(errors);
+    if (json.error || hasErrors) {
+        throw parseSwapError(JSON.stringify(json), `${label} returned an error`);
+    }
+}
+export async function listSwapNetworks(token, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-net");
+    logInfo("swap.networks.start", { correlationId });
+    try {
+        const json = await swpJson("/swp/refs/networks", {
+            method: "POST",
+            headers: { ...authHeaders(token), "Content-Type": "application/json" },
+            body: JSON.stringify({}),
+        }, { correlationId, label: "swap.networks", retry: true });
+        assertNoError(json, "list_swap_networks");
+        const items = json.items ?? [];
+        const result = items.map((i) => ({
+            id: typeof i.id === "number" ? i.id : undefined,
+            name: String(i.name ?? ""),
+            decimals: typeof i.decimals === "number" ? i.decimals : undefined,
+        }));
+        logInfo("swap.networks.ok", { correlationId, count: result.length });
+        return result;
+    }
+    catch (e) {
+        logError("swap.networks.fail", e, { correlationId });
+        throw e;
+    }
+}
+export async function listSwapAssetsFrom(token, params = {}, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-af");
+    const page = params.page ?? 1;
+    const pageSize = params.pageSize ?? 50;
+    const payload = {};
+    if (params.networks?.length) {
+        payload.networks = params.networks.map(capitalizeNetwork);
+    }
+    const q = params.search?.trim();
+    if (q)
+        payload.findBySymbol = q;
+    const json = await swpJson("/swp/refs/assets/from", {
+        method: "POST",
+        headers: { ...authHeaders(token), "Content-Type": "application/json" },
+        body: JSON.stringify({ page, pageSize, payload }),
+    }, { correlationId, label: "swap.assets.from", retry: true });
+    assertNoError(json, "list_swap_assets(from)");
+    return parseAssetsPage(json, page, pageSize);
+}
+export async function listSwapAssetsTo(token, params, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-at");
+    const page = params.page ?? 1;
+    const pageSize = params.pageSize ?? 50;
+    const body = {
+        page,
+        pageSize,
+        fromAsset: {
+            network: capitalizeNetwork(params.from.network),
+            symbol: canonicalSwapSymbol(params.from.symbol),
+            ...(params.from.address ? { address: params.from.address } : {}),
+        },
+    };
+    if (params.networks?.length) {
+        body.toNetworks = params.networks.map(capitalizeNetwork);
+    }
+    const q = params.search?.trim();
+    if (q)
+        body.findBySymbol = q;
+    const json = await swpJson("/swp/refs/assets/to", {
+        method: "POST",
+        headers: { ...authHeaders(token), "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    }, { correlationId, label: "swap.assets.to", retry: true });
+    assertNoError(json, "list_swap_assets(to)");
+    return parseAssetsPage(json, page, pageSize);
+}
+function parseAssetsPage(json, page, pageSize) {
+    const raw = json.items ?? [];
+    const items = raw.map((i) => ({
+        network: String(i.network ?? "").toLowerCase(),
+        symbol: canonicalSwapSymbol(String(i.symbol ?? "")),
+        decimals: Number(i.decimals ?? 0),
+        address: i.address == null || i.address === "" ? null : String(i.address),
+    }));
+    return {
+        items,
+        total: typeof json.total === "number" ? json.total : items.length,
+        page: typeof json.page === "number" ? json.page : page,
+        pageSize: typeof json.pageSize === "number" ? json.pageSize : pageSize,
+    };
+}
+export async function estimateSwap(token, params, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-est");
+    logInfo("swap.estimate.start", {
+        correlationId,
+        fromNetwork: params.from.asset.network,
+        toNetwork: params.to.asset.network,
+        fromSymbol: params.from.asset.symbol,
+        toSymbol: params.to.asset.symbol,
+        amount: params.from.amount,
+        maxMode: Boolean(params.maxMode),
+    });
+    try {
+        const json = await swpJson("/swp/exchange/estimate", {
+            method: "POST",
+            headers: { ...authHeaders(token), "Content-Type": "application/json" },
+            body: JSON.stringify({
+                from: sideToJson(params.from),
+                to: sideToJson(params.to),
+                maxMode: Boolean(params.maxMode),
+            }),
+        }, { correlationId, label: "swap.estimate", retry: true });
+        assertNoError(json, "estimate_swap");
+        const result = mapEstimate(json);
+        logInfo("swap.estimate.ok", {
+            correlationId,
+            operationId: result.operationId,
+            correctedAmountFrom: result.correctedAmountFrom,
+            amountTo: result.to.amount,
+        });
+        return result;
+    }
+    catch (e) {
+        logError("swap.estimate.fail", e, { correlationId });
+        throw e;
+    }
+}
+function mapSide(raw) {
+    const assetRaw = raw?.asset ?? {};
+    return {
+        asset: {
+            network: String(assetRaw.network ?? "").toLowerCase(),
+            symbol: canonicalSwapSymbol(String(assetRaw.symbol ?? "")),
+            decimals: Number(assetRaw.decimals ?? 0),
+            address: assetRaw.address == null || assetRaw.address === ""
+                ? null
+                : String(assetRaw.address),
+        },
+        address: String(raw?.address ?? ""),
+        amount: raw?.amount != null ? String(raw.amount) : undefined,
+    };
+}
+function mapEstimate(json) {
+    return {
+        operationId: String(json.operationId ?? ""),
+        provider: json.provider != null ? String(json.provider) : undefined,
+        from: mapSide(json.from),
+        to: mapSide(json.to),
+        correctedAmountFrom: json.correctedAmountFrom != null ? String(json.correctedAmountFrom) : undefined,
+        correctedAmountTo: json.correctedAmountTo != null ? String(json.correctedAmountTo) : undefined,
+        details: slimSwapDetails(json.details ?? undefined),
+        raw: json,
+    };
+}
+/** Agent-facing swap fees: network / tokenFee / coinFee only. */
+const SWAP_FEE_KEYS = ["network", "tokenFee", "coinFee"];
+function pickSwapFees(fees) {
+    if (!fees || typeof fees !== "object" || Array.isArray(fees))
+        return undefined;
+    const src = fees;
+    const out = {};
+    for (const key of SWAP_FEE_KEYS) {
+        if (src[key] !== undefined)
+            out[key] = src[key];
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function slimSwapDetails(details) {
+    if (!details)
+        return undefined;
+    if (!("fees" in details))
+        return details;
+    const { fees, ...rest } = details;
+    const slim = pickSwapFees(fees);
+    return slim ? { ...rest, fees: slim } : rest;
+}
+function slimSwapPayload(json) {
+    const next = { ...json };
+    if ("fees" in next) {
+        const slim = pickSwapFees(next.fees);
+        if (slim)
+            next.fees = slim;
+        else
+            delete next.fees;
+    }
+    if (next.details && typeof next.details === "object" && !Array.isArray(next.details)) {
+        next.details = slimSwapDetails(next.details);
+    }
+    return next;
+}
+export async function createSwap(token, params, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-crt");
+    logInfo("swap.create.start", {
+        correlationId,
+        operationId: params.operationId,
+        correctedAmountFrom: params.correctedAmountFrom,
+    });
+    try {
+        const json = await swpJson("/swp/exchange/create", {
+            method: "POST",
+            headers: {
+                ...authHeaders(token),
+                "Content-Type": "application/json",
+                "x-idempotency-key": params.operationId,
+            },
+            body: JSON.stringify({
+                operationId: params.operationId,
+                correctedAmountFrom: params.correctedAmountFrom,
+                from: sideToJson(params.from),
+                to: sideToJson(params.to),
+                maxMode: Boolean(params.maxMode),
+            }),
+        }, 
+        // Create is not safely retryable after acceptance; keep default POST no-retry.
+        { correlationId, label: "swap.create", retry: false });
+        assertNoError(json, "create_swap");
+        const order = json.order;
+        const txs = json.txsToSign ?? [];
+        const result = {
+            operationId: String(json.operationId ?? params.operationId),
+            swapOrderId: String(order?.uid ?? order?.id ?? ""),
+            provider: json.provider != null ? String(json.provider) : undefined,
+            txsToSign: txs.map((t) => ({
+                txId: t.txId != null ? String(t.txId) : undefined,
+                txData: t.txData != null ? String(t.txData) : undefined,
+                extraData: t.extraData != null ? String(t.extraData) : undefined,
+                type: t.type != null ? String(t.type) : undefined,
+            })),
+            raw: json,
+        };
+        logInfo("swap.create.ok", {
+            correlationId,
+            operationId: result.operationId,
+            swapOrderId: result.swapOrderId,
+            txCount: result.txsToSign.length,
+        });
+        return result;
+    }
+    catch (e) {
+        logError("swap.create.fail", e, {
+            correlationId,
+            operationId: params.operationId,
+        });
+        throw e;
+    }
+}
+export async function executeSwap(token, params, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-exe");
+    const cfg = getConfig();
+    logInfo("swap.execute.start", {
+        correlationId,
+        operationId: params.operationId,
+        swapOrderId: params.swapOrderId,
+        signedCount: params.signedTransactions.length,
+    });
+    try {
+        const json = await swpJson("/swp/exchange/execute", {
+            method: "POST",
+            headers: {
+                ...authHeaders(token),
+                "Content-Type": "application/json",
+                "x-idempotency-key": params.operationId,
+            },
+            body: JSON.stringify({
+                operationId: params.operationId,
+                swapOrderId: params.swapOrderId,
+                from: sideToJson(params.from),
+                to: sideToJson(params.to),
+                signedTransactions: params.signedTransactions,
+            }),
+        }, {
+            correlationId,
+            label: "swap.execute",
+            retry: false,
+            timeoutMs: cfg.httpForwardTimeoutMs,
+        });
+        assertNoError(json, "execute_swap");
+        const result = {
+            operationId: String(json.operationId ?? params.operationId),
+            txHash: json.txHash != null
+                ? String(json.txHash)
+                : json.hash != null
+                    ? String(json.hash)
+                    : undefined,
+            raw: json,
+        };
+        logInfo("swap.execute.ok", {
+            correlationId,
+            operationId: result.operationId,
+            txHash: result.txHash,
+        });
+        return result;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const timedOut = /timed out/i.test(msg);
+        logError("swap.execute.fail", e, {
+            correlationId,
+            operationId: params.operationId,
+            timedOut,
+            warning: "Swap may still be in progress. Poll get_swap_status before retrying.",
+        });
+        if (timedOut) {
+            throw new Error(`${msg}. The swap may still be processing — call get_swap_status ` +
+                `with operationId=${params.operationId} before retrying. ` +
+                `[correlationId=${correlationId}]`);
+        }
+        throw e;
+    }
+}
+export async function getSwapStatus(token, operationId, opts = {}) {
+    const correlationId = opts.correlationId ?? newCorrelationId("swp-st");
+    const json = await swpJson(`/swp/exchange/status/${encodeURIComponent(operationId)}`, {
+        method: "GET",
+        headers: authHeaders(token),
+    }, { correlationId, label: "swap.status", retry: true });
+    assertNoError(json, "get_swap_status");
+    return slimSwapPayload(json);
+}
+/** SWP allows up to 200; keep under the cap while limiting round-trips. */
+const RESOLVE_PAGE_SIZE = 100;
+/** Hard stop so a broken `total` cannot loop forever (~5k assets). */
+const RESOLVE_MAX_PAGES = 50;
+function matchAsset(items, ref) {
+    const wantNet = ref.network.toLowerCase();
+    const wantSym = ref.symbol.toLowerCase();
+    const wantAddr = (ref.address ?? "").toLowerCase();
+    return items.find((a) => a.network === wantNet &&
+        a.symbol.toLowerCase() === wantSym &&
+        (a.address ?? "").toLowerCase() === wantAddr);
+}
+/**
+ * Same network + symbol, different contracts — used for a clear error when the
+ * caller omitted `address` and the catalog is ambiguous.
+ */
+function sameSymbolOnNetwork(items, ref) {
+    const wantNet = ref.network.toLowerCase();
+    const wantSym = ref.symbol.toLowerCase();
+    return items.filter((a) => a.network === wantNet && a.symbol.toLowerCase() === wantSym);
+}
+async function findAssetAcrossPages(fetchPage, ref) {
+    let pageNum = 1;
+    let total = Number.POSITIVE_INFINITY;
+    let scanned = 0;
+    const symbolHits = [];
+    const wantAddr = (ref.address ?? "").toLowerCase();
+    while (pageNum <= RESOLVE_MAX_PAGES && scanned < total) {
+        const page = await fetchPage(pageNum, RESOLVE_PAGE_SIZE);
+        total = Number.isFinite(page.total) ? page.total : scanned + page.items.length;
+        scanned += page.items.length;
+        const hit = matchAsset(page.items, ref);
+        if (hit)
+            return { match: hit, scanned };
+        // Track collisions only when caller did not pin a contract address.
+        if (!wantAddr) {
+            for (const a of sameSymbolOnNetwork(page.items, ref)) {
+                const key = (a.address ?? "").toLowerCase();
+                if (!symbolHits.some((x) => (x.address ?? "").toLowerCase() === key)) {
+                    symbolHits.push(a);
+                }
+            }
+        }
+        if (page.items.length === 0)
+            break;
+        if (page.items.length < page.pageSize)
+            break;
+        if (pageNum * page.pageSize >= total)
+            break;
+        pageNum += 1;
+    }
+    if (!wantAddr && symbolHits.length > 1) {
+        // Prefer native (null address) when Max/agent omitted address.
+        const native = symbolHits.find((a) => !a.address);
+        if (native)
+            return { match: native, scanned };
+        return { scanned, ambiguous: symbolHits };
+    }
+    if (!wantAddr && symbolHits.length === 1) {
+        return { match: symbolHits[0], scanned };
+    }
+    return { scanned };
+}
+/**
+ * Resolve decimals for a short asset ref via SWP catalog.
+ * Sell assets: `/assets/from`. Buy assets: `/assets/to` (needs `from` context).
+ *
+ * Walks catalog pages (not just page 1). Prefer passing `decimals` from
+ * `list_swap_assets` to skip lookup entirely.
+ */
+export async function resolveSwapAsset(token, ref, opts = {}) {
+    if (ref.decimals !== undefined && Number.isFinite(ref.decimals)) {
+        return {
+            network: ref.network.toLowerCase(),
+            symbol: ref.symbol,
+            address: ref.address ?? null,
+            decimals: ref.decimals,
+        };
+    }
+    const networkFilter = [ref.network];
+    const fetchWithSearch = (page, pageSize) => opts.fromForToLookup
+        ? listSwapAssetsTo(token, {
+            from: opts.fromForToLookup,
+            search: ref.symbol,
+            networks: networkFilter,
+            page,
+            pageSize,
+        }, opts)
+        : listSwapAssetsFrom(token, {
+            search: ref.symbol,
+            networks: networkFilter,
+            page,
+            pageSize,
+        }, opts);
+    // 1) Symbol search + paginate (usual path).
+    let result = await findAssetAcrossPages(fetchWithSearch, ref);
+    // 2) Fallback: no findBySymbol — only network filter. Needed when search
+    //    ranking buries an exact symbol/address past RESOLVE_MAX_PAGES, or when
+    //    findBySymbol is too narrow. Still capped.
+    if (!result.match && !result.ambiguous && ref.address) {
+        const fetchNoSearch = (page, pageSize) => opts.fromForToLookup
+            ? listSwapAssetsTo(token, {
+                from: opts.fromForToLookup,
+                networks: networkFilter,
+                page,
+                pageSize,
+            }, opts)
+            : listSwapAssetsFrom(token, {
+                networks: networkFilter,
+                page,
+                pageSize,
+            }, opts);
+        result = await findAssetAcrossPages(fetchNoSearch, ref);
+    }
+    if (result.match)
+        return result.match;
+    if (result.ambiguous?.length) {
+        const sample = result.ambiguous
+            .slice(0, 5)
+            .map((a) => a.address ?? "native")
+            .join(", ");
+        throw new Error(`Asset ${ref.symbol} on ${ref.network} is ambiguous (${result.ambiguous.length} contracts). ` +
+            `Pass address (and preferably decimals) from list_swap_assets. Examples: ${sample}`);
+    }
+    throw new Error(`Asset ${ref.symbol} on ${ref.network}` +
+        (ref.address ? ` (${ref.address})` : " (native)") +
+        " not found in SWP catalog after paging. Pass decimals from list_swap_assets, or ensure the pair is valid.");
+}
+export function assetKey(a) {
+    return `${a.network.toLowerCase()}|${a.symbol.toLowerCase()}|${(a.address ?? "").toLowerCase()}`;
+}
+//# sourceMappingURL=swap.js.map