@orkid-labs/sdk 0.1.0

package/dist/cli.js

@@ -0,0 +1,856 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/chains.ts
+var chains_exports = {};
+__export(chains_exports, {
+  ORKID_CHAINS: () => ORKID_CHAINS,
+  ORKID_CHAIN_CONFIG: () => ORKID_CHAIN_CONFIG,
+  PERMIT2: () => PERMIT2,
+  chainConfigFromName: () => chainConfigFromName,
+  chainIdFromName: () => chainIdFromName,
+  chainNameFromId: () => chainNameFromId,
+  getPermit2Address: () => getPermit2Address,
+  normalizeChainName: () => normalizeChainName
+});
+function getPermit2Address() {
+  return PERMIT2;
+}
+function chainIdFromName(name) {
+  const normalized = normalizeChainName(name);
+  for (const config of Object.values(ORKID_CHAIN_CONFIG)) {
+    if (config.name === normalized) return config.id;
+  }
+  throw new Error(`Unsupported chain: ${name}`);
+}
+function chainNameFromId(chainId) {
+  const config = ORKID_CHAIN_CONFIG[chainId];
+  if (!config) throw new Error(`Unsupported chain id: ${chainId}`);
+  return config.name;
+}
+function chainConfigFromName(name) {
+  const normalized = normalizeChainName(name);
+  const config = Object.values(ORKID_CHAIN_CONFIG).find((c) => c.name === normalized);
+  if (!config) throw new Error(`Unsupported chain: ${name}`);
+  return config;
+}
+function normalizeChainName(name) {
+  const n = name.toLowerCase();
+  if (n === "mainnet") return "ethereum";
+  return n;
+}
+var PERMIT2, ORKID_CHAIN_CONFIG, ORKID_CHAINS;
+var init_chains = __esm({
+  "src/chains.ts"() {
+    "use strict";
+    PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    ORKID_CHAIN_CONFIG = {
+      8453: {
+        id: 8453,
+        name: "base",
+        shortName: "BASE",
+        color: "#0052FF",
+        permit2: PERMIT2,
+        tvmExecutor: "0x60AB9E090abF9B6BcFbA16017eE18AEf5f2c2289",
+        sandboxTvmExecutor: "0xD5B87788AF6F9E04E7FA298Bd973cEEA8c0Df0aF",
+        tychoRouter: "0x2D3524b9b5dAE34B646614eebb1E038D403E4Cac",
+        explorer: "https://basescan.org",
+        rpcUrl: "https://rpc.orkidlabs.com/rpc/base",
+        nativeSymbol: "ETH",
+        nativeDecimals: 18,
+        minNotionalUsd: 20,
+        isLive: true
+      },
+      1: {
+        id: 1,
+        name: "ethereum",
+        shortName: "ETH",
+        color: "#627EEA",
+        permit2: PERMIT2,
+        tvmExecutor: "0xCfc33b521190FcD414c8f81f479749c4dCE8f69b",
+        sandboxTvmExecutor: "0xd1b5c6e142fd95be389cc4ca117cb0fb7429534f",
+        tychoRouter: "0xfd0b31d2e955fa55e3fa641fe90e08b677188d35",
+        explorer: "https://etherscan.io",
+        rpcUrl: "https://rpc.orkidlabs.com/rpc/ethereum",
+        nativeSymbol: "ETH",
+        nativeDecimals: 18,
+        minNotionalUsd: 200,
+        isLive: true
+      },
+      130: {
+        id: 130,
+        name: "unichain",
+        shortName: "UNI",
+        color: "#FF007A",
+        permit2: PERMIT2,
+        tvmExecutor: "0x3fC25b3Ae57514e839f901cB1f628F8557150C2b",
+        sandboxTvmExecutor: "0x0000000000000000000000000000000000000000",
+        tychoRouter: "0xFfA5ec2e444e4285108e4a17b82dA495c178427B",
+        explorer: "https://unichain.blockscout.com",
+        rpcUrl: "https://unichain-rpc.publicnode.com",
+        nativeSymbol: "ETH",
+        nativeDecimals: 18,
+        minNotionalUsd: 200,
+        isLive: false
+      },
+      42161: {
+        id: 42161,
+        name: "arbitrum",
+        shortName: "ARB",
+        color: "#28A0F0",
+        permit2: PERMIT2,
+        tvmExecutor: "0xf57235609bf99fb0b017e95b3bc33a606a541374",
+        sandboxTvmExecutor: "0x9a4cd4ce4ca1dd554d337270b3353da9abb52c83",
+        tychoRouter: "0x924F147c50eA59f5180a26031A8b65B2aA1e81Cd",
+        explorer: "https://arbiscan.io",
+        rpcUrl: "https://rpc.orkidlabs.com/rpc/arbitrum",
+        nativeSymbol: "ETH",
+        nativeDecimals: 18,
+        minNotionalUsd: 50,
+        isLive: true
+      },
+      137: {
+        id: 137,
+        name: "polygon",
+        shortName: "POL",
+        color: "#8247E5",
+        permit2: PERMIT2,
+        tvmExecutor: "0xd633Ea84E6E2Db002C14C6fe3A064eE2cc4E258c",
+        sandboxTvmExecutor: "0x9a4cd4ce4ca1dd554d337270b3353da9abb52c83",
+        tychoRouter: "0xbd4e6011F03355C2A377Fd9Af939322A7d0A1bC1",
+        explorer: "https://polygonscan.com",
+        rpcUrl: "https://rpc.orkidlabs.com/rpc/polygon",
+        nativeSymbol: "MATIC",
+        nativeDecimals: 18,
+        minNotionalUsd: 50,
+        isLive: true
+      }
+    };
+    ORKID_CHAINS = ["base", "ethereum", "arbitrum", "polygon"];
+  }
+});
+
+// src/permit.ts
+function buildPermit2Domain(chainId) {
+  return {
+    name: "Permit2",
+    chainId,
+    verifyingContract: getPermit2Address()
+  };
+}
+function buildPermitMessage(params) {
+  return {
+    permitted: {
+      token: params.token,
+      amount: params.amount
+    },
+    spender: params.spender,
+    nonce: params.nonce,
+    deadline: params.deadline
+  };
+}
+function toOrkidPermit(message) {
+  return {
+    permitted: message.permitted,
+    nonce: message.nonce,
+    deadline: message.deadline
+  };
+}
+function parseAmount(value, decimals) {
+  const normalized = value.trim();
+  if (!/^\d+(\.\d+)?$/.test(normalized)) {
+    throw new Error(`Invalid amount: ${value}`);
+  }
+  const [whole, fraction = ""] = normalized.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`Amount ${value} exceeds ${decimals} decimals`);
+  }
+  const scale = BigInt("1" + "0".repeat(decimals));
+  const wholeBig = BigInt(whole) * scale;
+  const fractionBig = BigInt(fraction.padEnd(decimals, "0") || "0");
+  return (wholeBig + fractionBig).toString();
+}
+function formatAmount(raw, decimals) {
+  const rawBig = BigInt(raw);
+  const scale = BigInt("1" + "0".repeat(decimals));
+  const whole = (rawBig / scale).toString();
+  const fraction = (rawBig % scale).toString().padStart(decimals, "0");
+  const trimmed = fraction.replace(/0+$/, "");
+  return trimmed ? `${whole}.${trimmed}` : whole;
+}
+function buildSwapPermit(chainName, token, amount, nonce, deadlineSeconds) {
+  const chainConfig = chainConfigFromName(chainName);
+  const message = buildPermitMessage({
+    token,
+    amount,
+    nonce,
+    deadline: String(deadlineSeconds),
+    spender: chainConfig.tvmExecutor
+  });
+  const permit = toOrkidPermit(message);
+  return { message, permit, chainConfig };
+}
+function defaultDeadline() {
+  return Math.floor(Date.now() / 1e3) + 3600;
+}
+function buildNonce(wordPos, bitPos) {
+  return (wordPos << BigInt(8) | BigInt(bitPos)).toString();
+}
+var PERMIT2_ABI;
+var init_permit = __esm({
+  "src/permit.ts"() {
+    "use strict";
+    init_chains();
+    PERMIT2_ABI = [
+      {
+        type: "function",
+        name: "nonceBitmap",
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "wordPos", type: "uint256" }
+        ],
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view"
+      }
+    ];
+  }
+});
+
+// src/viem.ts
+var viem_exports = {};
+__export(viem_exports, {
+  OrkidViemPermitSigner: () => OrkidViemPermitSigner,
+  buildNonce: () => buildNonce,
+  buildPermit2Domain: () => buildPermit2Domain,
+  buildPermitMessage: () => buildPermitMessage,
+  buildSwapPermit: () => buildSwapPermit,
+  defaultDeadline: () => defaultDeadline,
+  formatAmount: () => formatAmount,
+  parseAmount: () => parseAmount,
+  toOrkidPermit: () => toOrkidPermit
+});
+function randomStartWord() {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const arr = new Uint32Array(1);
+    crypto.getRandomValues(arr);
+    return BigInt(arr[0] >>> 8);
+  }
+  return BigInt(Math.floor(Math.random() * 16777215));
+}
+var OrkidViemPermitSigner;
+var init_viem = __esm({
+  "src/viem.ts"() {
+    "use strict";
+    init_chains();
+    init_permit();
+    init_permit();
+    init_permit();
+    OrkidViemPermitSigner = class {
+      walletClient;
+      publicClient;
+      constructor(walletClient, publicClient) {
+        this.walletClient = walletClient;
+        this.publicClient = publicClient;
+      }
+      async findUnusedNonce(owner, maxWords = 1e3) {
+        const startWord = randomStartWord();
+        const max = BigInt(maxWords);
+        for (let offset = BigInt(0); offset < max; offset++) {
+          const wordPos = (startWord + offset) % BigInt(1e6);
+          const bitmap = await this.publicClient.readContract({
+            address: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+            abi: PERMIT2_ABI,
+            functionName: "nonceBitmap",
+            args: [owner, wordPos]
+          });
+          const bitmapBig = BigInt(String(bitmap));
+          if (bitmapBig === (BigInt(1) << BigInt(256)) - BigInt(1)) continue;
+          for (let bitPos = 0; bitPos < 256; bitPos++) {
+            const bit = BigInt(1) << BigInt(bitPos);
+            if ((bitmapBig & bit) === BigInt(0)) {
+              return buildNonce(wordPos, bitPos);
+            }
+          }
+        }
+        throw new Error("No unused Permit2 nonce found after scanning 1000 words");
+      }
+      async signSwap(params) {
+        const chainConfig = chainConfigFromName(params.chain);
+        const amountRaw = parseAmount(params.amount, params.fromDecimals);
+        const nonce = params.nonce || await this.findUnusedNonce(params.user);
+        const deadline = params.deadline || defaultDeadline();
+        const message = buildPermitMessage({
+          token: params.fromToken,
+          amount: amountRaw,
+          nonce,
+          deadline: String(deadline),
+          spender: chainConfig.tvmExecutor
+        });
+        const domain = buildPermit2Domain(chainConfig.id);
+        const account = this.walletClient.account ?? params.user;
+        const signature = await this.walletClient.signTypedData({
+          account,
+          domain,
+          types: {
+            PermitTransferFrom: [
+              { name: "permitted", type: "TokenPermissions" },
+              { name: "spender", type: "address" },
+              { name: "nonce", type: "uint256" },
+              { name: "deadline", type: "uint256" }
+            ],
+            TokenPermissions: [
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          primaryType: "PermitTransferFrom",
+          message: {
+            permitted: {
+              token: message.permitted.token,
+              amount: BigInt(message.permitted.amount)
+            },
+            spender: message.spender,
+            nonce: BigInt(message.nonce),
+            deadline: BigInt(message.deadline)
+          }
+        });
+        return {
+          permit: toOrkidPermit(message),
+          signature,
+          chainConfig
+        };
+      }
+      /**
+       * Read the ERC20 allowance of the user for the Permit2 contract.
+       */
+      async getPermit2Allowance(token, owner) {
+        const allowance = await this.publicClient.readContract({
+          address: token,
+          abi: [
+            {
+              type: "function",
+              name: "allowance",
+              inputs: [
+                { name: "owner", type: "address" },
+                { name: "spender", type: "address" }
+              ],
+              outputs: [{ name: "", type: "uint256" }],
+              stateMutability: "view"
+            }
+          ],
+          functionName: "allowance",
+          args: [owner, "0x000000000022D473030F116dDEE9F6B43aC78BA3"]
+        });
+        return BigInt(String(allowance));
+      }
+    };
+  }
+});
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://orkidlabs.xyz";
+var OrkidClient = class {
+  apiKey;
+  operatorSecret;
+  baseUrl;
+  fetch;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.operatorSecret = options.operatorSecret;
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.fetch = options.fetch || globalThis.fetch.bind(globalThis);
+    if (this.apiKey && !/^[a-f0-9]{40}$/i.test(this.apiKey)) {
+      throw new Error("OrkidClient: apiKey must be a 40-character hex string");
+    }
+  }
+  baseHeaders(json) {
+    const headers = {};
+    if (json) headers["Content-Type"] = "application/json";
+    if (this.apiKey) headers["X-ORKID-API-Key"] = this.apiKey;
+    if (this.operatorSecret) headers["X-ORKID-Operator"] = this.operatorSecret;
+    return headers;
+  }
+  /**
+   * Anonymous (keyless) browser calls can hit 403 when the anti-scrape token
+   * is missing or expired. Recover by hitting /api/v1/handshake (issues a
+   * fresh bound cookie) and retrying once.
+   */
+  async fetchWithHandshake(doFetch) {
+    let res = await doFetch();
+    if (res.status === 403 && !this.apiKey) {
+      const body = await res.clone().json().catch(() => null);
+      if (body && typeof body.error === "string" && /anti-scraping token/i.test(body.error)) {
+        try {
+          await this.fetch(`${this.baseUrl}/api/v1/handshake`, { credentials: "include" });
+        } catch {
+        }
+        res = await doFetch();
+      }
+    }
+    return res;
+  }
+  /**
+   * Get an executable quote for a swap.
+   */
+  async getQuote(request) {
+    return this.post("/api/v1/route", request);
+  }
+  /**
+   * Solve a swap gaslessly.
+   */
+  async solve(request) {
+    return this.post("/api/v1/solve", request);
+  }
+  /**
+   * Convenience wrapper: get a quote then dry-run solve the same swap with a
+   * pre-signed permit. Useful for testing signatures before live execution.
+   */
+  async dryRun(request) {
+    return this.solve({ ...request, dryRun: true });
+  }
+  /**
+   * Fetch a list of tokens for a chain from the Orkid token search endpoint.
+   * This is a convenience; the API key is optional for this read-only endpoint.
+   */
+  async listTokens(params = { chain: "base" }) {
+    const url = new URL(`${this.baseUrl}/api/v1/tokens`);
+    url.searchParams.set("chain", params.chain);
+    if (params.search) url.searchParams.set("search", params.search);
+    if (params.limit) url.searchParams.set("limit", String(params.limit));
+    const headers = this.baseHeaders(false);
+    const res = await this.fetchWithHandshake(() => this.fetch(url.toString(), { headers }));
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return { ok: false, error: `HTTP ${res.status}: ${text}` };
+    }
+    return res.json();
+  }
+  /**
+   * Fetch the partner account associated with this API key.
+   */
+  async getAccount() {
+    return this.get("/api/v1/account");
+  }
+  /**
+   * Fetch usage events for the partner account. Optionally filter by month
+   * (`period: 'YYYY-MM'`) and event type (`'route'` | `'solve'`).
+   */
+  async getUsage(params = {}) {
+    const query = {};
+    if (params.period) query.period = params.period;
+    if (params.eventType) query.event_type = params.eventType;
+    if (params.limit) query.limit = String(params.limit);
+    return this.get("/api/v1/usage", query);
+  }
+  /**
+   * Fetch the rebate ledger for the partner account. Optionally filter by
+   * month (`period: 'YYYY-MM'`).
+   */
+  async getRebates(params = {}) {
+    const query = {};
+    if (params.period) query.period = params.period;
+    return this.get("/api/v1/rebates", query);
+  }
+  /**
+   * Health check on the API. The API key is optional here.
+   */
+  async getStatus() {
+    return this.get("/api/v1/status");
+  }
+  /**
+   * Confirm a user-submitted swap (user-pays-gas mode, e.g. below the gasless
+   * floor). The API verifies the tx on-chain and counts it as a real solve —
+   * this is what makes user-paid volume rebate-eligible.
+   */
+  async confirmTransaction(txHash, chain) {
+    const headers = this.baseHeaders(true);
+    const res = await this.fetchWithHandshake(
+      () => this.fetch(`${this.baseUrl}/api/v1/confirm`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ txHash, chain })
+      })
+    );
+    const data = await res.json().catch(() => null);
+    return data ?? { ok: false, error: `HTTP ${res.status}: empty response` };
+  }
+  async get(path, query = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [k, v] of Object.entries(query)) url.searchParams.set(k, v);
+    const headers = this.baseHeaders(false);
+    const res = await this.fetchWithHandshake(() => this.fetch(url.toString(), { headers }));
+    const data = await res.json().catch(() => null);
+    if (!data) {
+      return { ok: false, error: `HTTP ${res.status}: empty response` };
+    }
+    return data;
+  }
+  async post(path, body) {
+    const headers = this.baseHeaders(true);
+    const res = await this.fetchWithHandshake(
+      () => this.fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      })
+    );
+    const data = await res.json().catch(() => null);
+    if (!data) {
+      return {
+        ok: false,
+        error: `HTTP ${res.status}: empty response`,
+        computeMs: 0
+      };
+    }
+    return data;
+  }
+};
+
+// src/cli.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  let command;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      flags.help = true;
+    } else if (arg === "--json") {
+      flags.json = true;
+    } else if (arg === "--execute") {
+      flags.execute = true;
+    } else if (arg === "--dry-run") {
+      flags.dryRun = true;
+    } else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (!command) {
+      command = arg;
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, positional, flags };
+}
+function flag(flags, ...names) {
+  for (const n of names) {
+    const v = flags[n];
+    if (typeof v === "string") return v;
+  }
+  return void 0;
+}
+function num(flags, ...names) {
+  const v = flag(flags, ...names);
+  return v === void 0 ? void 0 : Number(v);
+}
+function die(message, code = 1) {
+  console.error(`error: ${message}`);
+  process.exit(code);
+}
+function print(data, json, formatter) {
+  if (json || !formatter) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  formatter(data);
+}
+var HELP = `orkid \u2014 Orkid swap API CLI
+
+Commands:
+  quote     Get an executable swap quote
+              --from <sym> --to <sym> --amount <n> [--chain base]
+              [--from-address 0x.. --from-decimals n --to-address 0x.. --to-decimals n]
+  solve     Sign + submit a gasless swap (needs viem + ORKID_PRIVATE_KEY)
+              same flags as quote, plus --user 0x.. --execute (default: dry-run)
+  tokens    List tokens for a chain
+              [--chain base] [--search <q>] [--limit n]
+  account   Show the partner account for this API key
+  usage     List usage events for this API key's account
+              [--period YYYY-MM] [--event-type route|solve] [--limit n]
+  rebates   List rebate ledger entries for this API key's account
+              [--period YYYY-MM]
+  confirm   Confirm a user-submitted swap tx (counts it toward volume/rebates)
+              orkid confirm <txHash> [--chain base]
+  status    API health check
+
+Global flags:
+  --api-key <40-hex>   Orkid API key (or ORKID_API_KEY env)
+  --base-url <url>     API base URL (or ORKID_API_URL env, default https://orkidlabs.xyz)
+  --test               Operator test mode (requires ORKID_OPERATOR_SECRET)
+  --json               Raw JSON output
+  -h, --help           This help
+
+Environment:
+  ORKID_API_KEY        Partner API key
+  ORKID_API_URL        Override API base URL
+  ORKID_PRIVATE_KEY    Wallet private key for 'solve' signing (hex, 0x-prefixed)
+  ORKID_OPERATOR_SECRET  Operator test mode \u2014 marks usage as test (no rebate impact)
+`;
+async function main() {
+  const { command, positional, flags } = parseArgs(process.argv.slice(2));
+  if (!command || flags.help) {
+    console.log(HELP);
+    process.exit(command ? 0 : 1);
+  }
+  const apiKey = flag(flags, "api-key", "apiKey") || process.env.ORKID_API_KEY;
+  const baseUrl = flag(flags, "base-url", "baseUrl", "url") || process.env.ORKID_API_URL;
+  const json = Boolean(flags.json);
+  const testMode = Boolean(flags.test);
+  const operatorSecret = process.env.ORKID_OPERATOR_SECRET;
+  if (testMode && !operatorSecret) {
+    console.error("warning: --test without ORKID_OPERATOR_SECRET will record normal volume");
+  }
+  if (testMode && operatorSecret) {
+    console.error("test mode: usage events marked is_test \u2014 excluded from rebates");
+  }
+  const client = new OrkidClient({ apiKey, baseUrl, operatorSecret: testMode ? operatorSecret : void 0 });
+  switch (command) {
+    case "quote": {
+      const req = routeRequest(flags);
+      const res = await client.getQuote(req);
+      print(res, json, (r) => {
+        if (!r.ok) return die(r.error || "quote failed");
+        const q = r.quote;
+        console.log(`${req.amount} ${req.from} -> ${q.amountOut} ${req.to}  (${q.rate})`);
+        console.log(`protocol:  ${q.protocol}`);
+        console.log(`volume:    $${q.volumeUsd}`);
+        if (r.savings) {
+          console.log(`savings:   ${r.savings.savingsBps} bps vs MetaMask ($${r.savings.savingsUsd})`);
+          console.log(`orkid fee: ${r.savings.orkidBps} bps`);
+        }
+        if (q.priceImpactBps !== void 0) console.log(`impact:    ${q.priceImpactBps} bps`);
+        console.log(`compute:   ${r.computeMs}ms`);
+      });
+      if (!res.ok) process.exit(1);
+      break;
+    }
+    case "solve": {
+      const res = await cmdSolve(client, flags);
+      print(res, json, (r) => {
+        if (!r.ok) return die(r.error || "solve failed");
+        if (r.transaction?.txHash) console.log(`tx: ${r.transaction.txHash}`);
+        else console.log(`calldata ready: to=${r.transaction?.to}`);
+        if (r.savings) console.log(`savings: ${r.savings.savingsBps} bps ($${r.savings.savingsUsd})`);
+      });
+      if (!res.ok) process.exit(1);
+      break;
+    }
+    case "tokens": {
+      const res = await client.listTokens({
+        chain: flag(flags, "chain") || "base",
+        search: flag(flags, "search"),
+        limit: num(flags, "limit")
+      });
+      print(res, json, (r) => {
+        if (!r.ok) return die(r.error || "token lookup failed");
+        for (const t of r.tokens || []) {
+          console.log(`${t.symbol.padEnd(10)} ${t.address}  (${t.decimals} decimals, ${t.chain})`);
+        }
+        if (!r.tokens?.length) console.log("no tokens found");
+      });
+      if (!res.ok) process.exit(1);
+      break;
+    }
+    case "account": {
+      const res = await client.getAccount();
+      print(res, json, (r) => {
+        if (!r.ok || !r.account) return die(r.error || "account lookup failed");
+        const a = r.account;
+        console.log(`${a.name} (${a.slug})`);
+        console.log(`id:           ${a.id}`);
+        console.log(`rebate:       ${a.rebate_bps} bps ${a.rebate_active ? "(active)" : "(inactive)"}`);
+        if (a.contact_email) console.log(`contact:      ${a.contact_email}`);
+      });
+      if (!res.ok) process.exit(1);
+      break;
+    }
+    case "usage": {
+      const res = await client.getUsage({
+        period: flag(flags, "period", "month"),
+        eventType: flag(flags, "event-type", "eventType", "type"),
+        limit: num(flags, "limit")
+      });
+      print(res, json, (r) => {
+        if (r.error) return die(r.error);
+        for (const e of r.events || []) {
+          const vol = e.volume_usd != null ? `$${e.volume_usd}` : "-";
+          const dry = e.is_dry_run ? " [dry-run]" : "";
+          console.log(`${e.created_at}  ${e.event_type.padEnd(6)} ${String(e.token_in || "-").padEnd(6)}->${String(e.token_out || "-").padEnd(6)} ${vol}${dry}`);
+        }
+        console.log(`---
+total volume: $${r.total_volume_usd ?? 0}   total savings: $${r.total_savings_usd ?? 0}`);
+      });
+      if (res.error) process.exit(1);
+      break;
+    }
+    case "rebates": {
+      const res = await client.getRebates({ period: flag(flags, "period", "month") });
+      print(res, json, (r) => {
+        if (r.error) return die(r.error);
+        for (const b of r.rebates || []) {
+          const month = String(b.period_start).slice(0, 7);
+          console.log(`${month}  volume=$${b.volume_usd}  rate=${b.rebate_bps}bps  rebate=$${b.rebate_usd}  [${b.status}]`);
+        }
+        if (!r.rebates?.length) console.log("no rebates accrued yet");
+      });
+      if (res.error) process.exit(1);
+      break;
+    }
+    case "confirm": {
+      const txHash = flag(flags, "tx-hash", "txHash", "tx") || positional[0];
+      if (!txHash) die("confirm requires a tx hash: orkid confirm 0x...");
+      const res = await client.confirmTransaction(txHash, flag(flags, "chain"));
+      print(res, json, (r) => {
+        if (r.confirmed) {
+          console.log(`confirmed \u2014 event ${r.eventId} now counts toward volume/rebates`);
+        } else {
+          die(r.error || "not confirmed");
+        }
+      });
+      if (!res.confirmed) process.exit(1);
+      break;
+    }
+    case "status": {
+      const res = await client.getStatus();
+      print(res, json, (r) => console.log(r.ok === false ? "API unreachable" : JSON.stringify(r)));
+      break;
+    }
+    default:
+      console.error(`unknown command: ${command}
+`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+function routeRequest(flags) {
+  const from = flag(flags, "from");
+  const to = flag(flags, "to");
+  const amount = flag(flags, "amount");
+  if (!from || !to || !amount) die("quote requires --from, --to, and --amount");
+  return {
+    from,
+    to,
+    amount,
+    chain: flag(flags, "chain") || "base",
+    fromAddress: flag(flags, "from-address", "fromAddress"),
+    fromDecimals: num(flags, "from-decimals", "fromDecimals"),
+    toAddress: flag(flags, "to-address", "toAddress"),
+    toDecimals: num(flags, "to-decimals", "toDecimals")
+  };
+}
+async function cmdSolve(client, flags) {
+  const req = routeRequest(flags);
+  if (!req.fromAddress || req.fromDecimals === void 0) {
+    die("solve requires --from-address and --from-decimals (token-in contract + decimals)");
+  }
+  const privateKey = flag(flags, "private-key", "privateKey") || process.env.ORKID_PRIVATE_KEY;
+  if (!privateKey) die("solve requires --private-key or ORKID_PRIVATE_KEY");
+  let viem, accounts, chainsMod;
+  try {
+    viem = await import("viem");
+    accounts = await import("viem/accounts");
+    chainsMod = await import("viem/chains");
+  } catch {
+    die("solve requires viem \u2014 run: npm install viem");
+  }
+  const { OrkidViemPermitSigner: OrkidViemPermitSigner2 } = await Promise.resolve().then(() => (init_viem(), viem_exports));
+  const { chainConfigFromName: chainConfigFromName2 } = await Promise.resolve().then(() => (init_chains(), chains_exports));
+  const chainConfig = chainConfigFromName2(req.chain || "base");
+  const account = accounts.privateKeyToAccount(privateKey);
+  const viemChain = Object.values(chainsMod).find((c) => c.id === chainConfig.id);
+  if (!viemChain) die(`no viem chain config for chain id ${chainConfig.id}`);
+  const walletClient = viem.createWalletClient({
+    account,
+    chain: viemChain,
+    transport: viem.http(chainConfig.rpcUrl)
+  });
+  const publicClient = viem.createPublicClient({
+    chain: viemChain,
+    transport: viem.http(chainConfig.rpcUrl)
+  });
+  const user = flag(flags, "user") || account.address;
+  const signer = new OrkidViemPermitSigner2(walletClient, publicClient);
+  const { permit, signature } = await signer.signSwap({
+    user,
+    fromToken: req.fromAddress,
+    fromDecimals: req.fromDecimals,
+    amount: req.amount,
+    chain: req.chain || "base"
+  });
+  const dryRun = !flags.execute;
+  if (!dryRun) {
+    console.error("submitting live swap...");
+  }
+  const res = await client.solve({
+    ...req,
+    user,
+    permit,
+    signature,
+    dryRun,
+    slippageBps: num(flags, "slippage-bps", "slippageBps")
+  });
+  if (flags.execute && !res.ok && res.gaslessEligible === false) {
+    console.error("below gasless minimum \u2014 submitting user-paid transaction...");
+    const encoded = await client.solve({
+      ...req,
+      user,
+      permit,
+      signature,
+      dryRun: true,
+      slippageBps: num(flags, "slippage-bps", "slippageBps")
+    });
+    if (!encoded.ok || !encoded.transaction?.data) return encoded;
+    const txHash = await walletClient.sendTransaction({
+      to: encoded.transaction.to,
+      data: encoded.transaction.data,
+      value: BigInt(encoded.transaction.value || "0")
+    });
+    console.error(`user-paid tx submitted: ${txHash} \u2014 waiting for confirmation...`);
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    const confirm = await client.confirmTransaction(txHash, req.chain || "base");
+    if (!confirm.confirmed) {
+      console.error(`warning: swap settled on-chain but not recorded (${confirm.error || "confirm failed"})`);
+    }
+    return {
+      ...encoded,
+      transaction: { ...encoded.transaction, txHash }
+    };
+  }
+  return res;
+}
+main().catch((e) => die(e instanceof Error ? e.message : String(e)));