Your UI, our routing.

npm i @swapspro/sdk

# Or build it from the repo — the package is the folder, nothing is generated
# that is not committed:
#   git clone https://github.com/coinmastersguild/swapspro.git
#   cd swapspro && npm install && npm run sdk:build   # tsc -> packages/sdk/dist

import { SwapsPro } from "@swapspro/sdk";

const swaps = new SwapsPro({
  partner: "my-app",       // your integrator id, attached to every quote
  partnerFeeBps: 25,       // optional additive fee, capped at 100 (1%)
  // baseUrl: "https://www.swaps.pro",  // default
  // fetch: myFetch,                    // for tests or exotic runtimes
});

const chains = await swaps.chains();

// [
//   { id: "ETH",  name: "Ethereum", nativeSymbol: "ETH", caip2: "eip155:1",    type: "evm",  chainId: 1 },
//   { id: "BTC",  name: "Bitcoin",  nativeSymbol: "BTC", caip2: "bip122:0000...", type: "utxo" },
//   { id: "BASE", name: "Base",     nativeSymbol: "ETH", caip2: "eip155:8453", type: "evm",  chainId: 8453 },
//   { id: "SOL",  name: "Solana",   nativeSymbol: "SOL", caip2: "solana:5eyk...",  type: "svm",  sellSupported: false },
//   ...
// ]

const tokens = await swaps.tokens(8453);   // numeric id
const same   = await swaps.tokens("BASE");  // or the chain symbol

// [
//   { symbol: "ETH",  name: "Base",           caip: "eip155:8453/slip44:60", chain: "BASE", isToken: false, decimals: 18 },
//   { symbol: "USDC", name: "USD Coin",       caip: "eip155:8453/erc20:0x8335...", chain: "BASE", isToken: true, contract: "0x8335...", decimals: 6 },
//   { symbol: "WETH", name: "Wrapped Ether",  caip: "eip155:8453/erc20:0x4200...", chain: "BASE", isToken: true, contract: "0x4200...", decimals: 18 },
// ]

const quote = await swaps.quote({
  sellChain: 8453,          // numeric EVM chain id, or a symbol like "BTC"
  sellToken: "ETH",         // symbol, asset CAIP, or a bare 0x contract address
  buyChain: 8453,
  buyToken: "USDC",
  amount: "0.1",            // decimal, human units — never base units
  address: account,         // sender on the sell chain
  // recipient: "0x…",      // required when sellChain !== buyChain
  // slippage: 1,           // percent, 0 < s <= 50
});

console.log(quote.provider, quote.buyAmount, quote.rate);

// 1. Sign it. executeSwap checks the wallet's chain, grants the ERC-20
//    allowance if the quote needs one (waiting for that approval to mine),
//    then sends the swap transaction.
const txHash = await swaps.executeSwap(quote, window.ethereum);

// 2. Wait for it. Poll through the same signer, or through a plain RPC URL.
const receipt = await swaps.waitForReceipt(txHash, { signer: window.ethereum });
console.log("mined in block", parseInt(receipt.blockNumber, 16));

import { SwapsPro, ChainMismatchError, NotSupportedError, SwapsProError } from "@swapspro/sdk";

try {
  const txHash = await swaps.executeSwap(quote, window.ethereum);
} catch (e) {
  if (e instanceof ChainMismatchError) {
    // The wallet is on e.actual, the quote needs e.expected.
    await window.ethereum.request({
      method: "wallet_switchEthereumChain",
      params: [{ chainId: `0x${e.expected.toString(16)}` }],
    });
  } else if (e instanceof NotSupportedError) {
    // Memo route: send quote.sellAmount to quote.depositAddress with quote.memo,
    // using a wallet for the sell chain. There is no EVM tx to sign.
  } else if (e instanceof SwapsProError) {
    console.error(e.code, e.status, e.message);
  }
}

import { SwapsPro, NotSupportedError } from "@swapspro/sdk";

const quote = await swaps.quote({ /* … */ });

if (quote.order) {
  // A signature-settled route (CoW). Gasless, asynchronous, and it can expire
  // unfilled. Three steps, plus the one-time vault-relayer approval.
  const { order } = quote;

  await fetch(order.appDataUrl, {
    method: "PUT",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ fullAppData: order.appData.fullAppData }),
  });

  const signature = await eth.request({
    method: "eth_signTypedData_v4",
    params: [account, JSON.stringify(order.typedData)],
  });

  await fetch(order.postUrl, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ ...order.body, signature, signingScheme: order.signingScheme }),
  });
} else {
  // A transaction route. executeSwap throws NotSupportedError on the ones it
  // cannot send, and its message names the steps above.
  const txHash = await swaps.executeSwap(quote, eth);
}

"use client";

import { useState } from "react";
import { SwapsPro, ChainMismatchError } from "@swapspro/sdk";

// One client for the whole app. The partner id rides on every quote.
const swaps = new SwapsPro({ partner: "skatehive", partnerFeeBps: 25 });

export function SwapButton() {
  const [amount, setAmount] = useState("0.01");
  const [preview, setPreview] = useState("");
  const [status, setStatus] = useState("");

  // Quote as the user types. Your inputs, your layout, your design system —
  // the SDK only prices the trade and hands back a transaction.
  async function onQuote(next: string) {
    setAmount(next);
    const eth = window.ethereum!;
    const [account] = (await eth.request({ method: "eth_accounts" })) as string[];
    if (!account || !(Number(next) > 0)) return setPreview("");

    const quote = await swaps.quote({
      sellChain: 8453, sellToken: "ETH",
      buyChain: 8453, buyToken: "USDC",
      amount: next, address: account,
    });
    setPreview(`${quote.buyAmount} USDC via ${quote.provider}`);
  }

  async function onSwap() {
    const eth = window.ethereum!;
    const [account] = (await eth.request({ method: "eth_requestAccounts" })) as string[];

    const quote = await swaps.quote({
      sellChain: 8453, sellToken: "ETH",
      buyChain: 8453, buyToken: "USDC",
      amount, address: account,
    });

    try {
      setStatus("Confirm in your wallet…");
      const txHash = await swaps.executeSwap(quote, eth);
      setStatus("Waiting for the network…");
      const receipt = await swaps.waitForReceipt(txHash, { signer: eth });
      setStatus(`Swapped in block ${parseInt(receipt.blockNumber, 16)}`);
    } catch (e) {
      if (e instanceof ChainMismatchError) {
        await eth.request({
          method: "wallet_switchEthereumChain",
          params: [{ chainId: `0x${e.expected.toString(16)}` }],
        });
        return onSwap(); // retry on the right chain
      }
      throw e;
    }
  }

  return (
    <div>
      <input value={amount} onChange={(e) => onQuote(e.target.value)} />
      <p>{preview}</p>
      <button onClick={onSwap}>Swap</button>
      <p>{status}</p>
    </div>
  );
}

# Python, Go, Rust, Unity, a shell script — anything that speaks HTTP.
BASE=https://www.swaps.pro/api/sdk/v1

curl -s "$BASE/quote?sellChain=8453&sellToken=ETH&buyChain=8453&buyToken=USDC\
&amount=0.1&address=0xYourAddress&partner=my-app&partnerFeeBps=25"

# Same-chain EVM: the response carries tx (and approval for ERC-20 sells).
# Pass tx straight to eth_sendTransaction — the quantities are already 0x-hex.

const BASE = "https://www.swaps.pro/api/sdk/v1";

const params = new URLSearchParams({
  sellChain: "8453", sellToken: "ETH",
  buyChain: "8453", buyToken: "USDC",
  amount: "0.1", address: account,
  partner: "my-app",
});

const res = await fetch(`${BASE}/quote?${params}`);
const quote = await res.json();
if (!res.ok) throw new Error(`${quote.code}: ${quote.error}`);

// Approve first when selling an ERC-20 (quote.approval), then send the swap.
const txHash = await window.ethereum.request({
  method: "eth_sendTransaction",
  params: [{
    from: account,
    to: quote.tx.to,
    data: quote.tx.data,
    value: quote.tx.value,
    gas: quote.tx.gasLimit,
  }],
});

const quote = await swaps.quote({ /* … */ });

// Did this route actually pay you? Ask the quote, do not assume.
console.log(quote.provider);              // "lifi"
console.log(quote.partnerFee?.collected); // true
console.log(quote.partnerFee?.note);
// "Collected on-chain: 25 bps added to SwapsPro's 30 bps in the LI.FI
//  integrator fee. LI.FI supports a single fee wallet, so your share is
//  settled to you from the quote log."

// On a route that cannot carry one, partnerFeeBps is ABSENT and the note says why:
// "NOT collected: this route was priced by Pioneer, whose venues expose no
//  affiliate field we can add a partner fee to (and rewriting a THORChain
//  memo's bps would invalidate the quote's own limit). Quote for a pair CoW,
//  LI.FI or 0x can route to earn on it."