@orkid-labs/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,640 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ORKID_CHAINS: () => ORKID_CHAINS,
+  ORKID_CHAIN_CONFIG: () => ORKID_CHAIN_CONFIG,
+  OrkidClient: () => OrkidClient,
+  OrkidEthersPermitSigner: () => OrkidEthersPermitSigner,
+  OrkidViemPermitSigner: () => OrkidViemPermitSigner,
+  PERMIT2: () => PERMIT2,
+  PERMIT2_ABI: () => PERMIT2_ABI,
+  PERMIT_TRANSFER_FROM_TYPES: () => PERMIT_TRANSFER_FROM_TYPES,
+  SANDBOX_BASE_URL: () => SANDBOX_BASE_URL,
+  buildNonce: () => buildNonce,
+  buildPermit2Domain: () => buildPermit2Domain,
+  buildPermitMessage: () => buildPermitMessage,
+  buildSwapPermit: () => buildSwapPermit,
+  chainConfigFromName: () => chainConfigFromName,
+  chainIdFromName: () => chainIdFromName,
+  chainNameFromId: () => chainNameFromId,
+  defaultDeadline: () => defaultDeadline,
+  formatAmount: () => formatAmount,
+  getPermit2Address: () => getPermit2Address,
+  normalizeChainName: () => normalizeChainName,
+  parseAmount: () => parseAmount,
+  randomStartWord: () => randomStartWord,
+  toOrkidPermit: () => toOrkidPermit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://orkidlabs.xyz";
+var SANDBOX_BASE_URL = "https://sandbox.orkidlabs.com";
+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/chains.ts
+var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+function getPermit2Address() {
+  return PERMIT2;
+}
+var 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
+  }
+};
+var ORKID_CHAINS = ["base", "ethereum", "arbitrum", "polygon"];
+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;
+}
+
+// src/permit.ts
+var PERMIT_TRANSFER_FROM_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" }
+  ]
+};
+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();
+}
+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 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 OrkidViemPermitSigner = class {
+  walletClient;
+  publicClient;
+  constructor(walletClient, publicClient) {
+    this.walletClient = walletClient;
+    this.publicClient = publicClient;
+  }
+  async findUnusedNonce(owner, maxWords = 1e3) {
+    const startWord = randomStartWord2();
+    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));
+  }
+};
+function randomStartWord2() {
+  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));
+}
+
+// src/ethers.ts
+var import_ethers = require("ethers");
+var OrkidEthersPermitSigner = class {
+  signer;
+  provider;
+  constructor(signer, provider) {
+    this.signer = signer;
+    this.provider = provider;
+  }
+  async findUnusedNonce(owner, maxWords = 1e3) {
+    const startWord = randomStartWord3();
+    const max = BigInt(maxWords);
+    const permit2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    const iface = new import_ethers.ethers.Interface([
+      "function nonceBitmap(address owner, uint256 wordPos) view returns (uint256)"
+    ]);
+    for (let offset = BigInt(0); offset < max; offset++) {
+      const wordPos = (startWord + offset) % BigInt(1e6);
+      const data = iface.encodeFunctionData("nonceBitmap", [owner, wordPos]);
+      const result = await this.provider.call({ to: permit2, data });
+      const bitmap = BigInt(result);
+      const allBits = (BigInt(1) << BigInt(256)) - BigInt(1);
+      if (bitmap === allBits) continue;
+      for (let bitPos = 0; bitPos < 256; bitPos++) {
+        const bit = BigInt(1) << BigInt(bitPos);
+        if ((bitmap & 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 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" }
+      ]
+    };
+    const signature = await this.signer.signTypedData(
+      domain,
+      types,
+      message
+    );
+    return {
+      permit: toOrkidPermit(message),
+      signature,
+      chainConfig
+    };
+  }
+  async getPermit2Allowance(token, owner) {
+    const permit2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    const iface = new import_ethers.ethers.Interface([
+      "function allowance(address owner, address spender) view returns (uint256)"
+    ]);
+    const data = iface.encodeFunctionData("allowance", [owner, permit2]);
+    const result = await this.provider.call({ to: token, data });
+    return BigInt(result);
+  }
+};
+function randomStartWord3() {
+  if (typeof crypto !== "undefined" && "getRandomValues" in crypto) {
+    const arr = new Uint32Array(1);
+    crypto.getRandomValues(arr);
+    return BigInt(arr[0] >> 8);
+  }
+  return BigInt(Math.floor(Math.random() * 16777215));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ORKID_CHAINS,
+  ORKID_CHAIN_CONFIG,
+  OrkidClient,
+  OrkidEthersPermitSigner,
+  OrkidViemPermitSigner,
+  PERMIT2,
+  PERMIT2_ABI,
+  PERMIT_TRANSFER_FROM_TYPES,
+  SANDBOX_BASE_URL,
+  buildNonce,
+  buildPermit2Domain,
+  buildPermitMessage,
+  buildSwapPermit,
+  chainConfigFromName,
+  chainIdFromName,
+  chainNameFromId,
+  defaultDeadline,
+  formatAmount,
+  getPermit2Address,
+  normalizeChainName,
+  parseAmount,
+  randomStartWord,
+  toOrkidPermit
+});