@blazephoenix/sdk 0.4.0

package/dist/index.cjs

@@ -0,0 +1,564 @@
+'use strict';
+
+// src/constants.ts
+var API_BASE = "https://blazephoenix.xyz";
+var CHAINS = {
+  1: {
+    chainId: 1,
+    name: "Ethereum",
+    explorer: "https://etherscan.io",
+    weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    contracts: {
+      hub: "0xc4FA9a5720fe3294D3AA9fc427E2a760591E57ae",
+      solver: "0xc124d91258db0C14bf13b826CF64E16bfEA8a73e",
+      router: "0xE1aE5f49013920CF71De8CED4043e14C4d63416b",
+      quoter: "0x4a20AA0912388ff7A9221Ab6BFC224cc20Baa0c3"
+    }
+  },
+  8453: {
+    chainId: 8453,
+    name: "Base",
+    explorer: "https://basescan.org",
+    weth: "0x4200000000000000000000000000000000000006",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    bzpx: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
+    contracts: {
+      hub: "0x428554DEe93A1B8B5Bc6Fd19adDAfe55106fc04C",
+      solver: "0xB1902990260975dD4C89ad74B1f317bc100CB830",
+      router: "0x2a779f9Be49aac57495A8B6467Cc325a8a47Eb9f",
+      quoter: "0x4cEF0615614B212895F45Aa1D4833B16666E18d3"
+    }
+  },
+  10: {
+    chainId: 10,
+    name: "Optimism",
+    explorer: "https://optimistic.etherscan.io",
+    weth: "0x4200000000000000000000000000000000000006",
+    usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    contracts: {
+      hub: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
+      solver: "0x0c0d96B237FABa8FE5e8aE77754Ef29109D2B33f",
+      router: "0x7262e7483ab6f0db7b8f90eC3a9de3B02Ab36F6A",
+      quoter: "0xfB18EF6f62A0278A273Af4b7A46b454F9E482dc2"
+    }
+  },
+  42161: {
+    chainId: 42161,
+    name: "Arbitrum",
+    explorer: "https://arbiscan.io",
+    weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    contracts: {
+      hub: "0x23113e72165a034265Ab8Bf2277CCB7a85Cb7483",
+      solver: "0x0c0d96B237FABa8FE5e8aE77754Ef29109D2B33f",
+      router: "0x7262e7483ab6f0db7b8f90eC3a9de3B02Ab36F6A",
+      quoter: "0xfB18EF6f62A0278A273Af4b7A46b454F9E482dc2"
+    }
+  }
+};
+function resolveChain(chain) {
+  const aliases = {
+    "1": 1,
+    eth: 1,
+    ethereum: 1,
+    mainnet: 1,
+    "8453": 8453,
+    base: 8453,
+    "10": 10,
+    op: 10,
+    optimism: 10,
+    "42161": 42161,
+    arb: 42161,
+    arbitrum: 42161,
+    "arbitrum-one": 42161
+  };
+  const id = aliases[String(chain).trim().toLowerCase()];
+  if (!id) {
+    throw new Error(
+      `Unsupported chain "${chain}" \u2014 use 8453/base, 1/eth, 10/optimism or 42161/arbitrum`
+    );
+  }
+  return id;
+}
+var PUBLIC_RPCS = {
+  1: [
+    "https://ethereum-rpc.publicnode.com",
+    "https://cloudflare-eth.com",
+    "https://1rpc.io/eth"
+  ],
+  8453: [
+    "https://mainnet.base.org",
+    "https://base-rpc.publicnode.com",
+    "https://1rpc.io/base"
+  ],
+  10: [
+    "https://optimism-rpc.publicnode.com",
+    "https://mainnet.optimism.io",
+    "https://1rpc.io/op"
+  ],
+  42161: [
+    "https://arbitrum-one-rpc.publicnode.com",
+    "https://arb1.arbitrum.io/rpc",
+    "https://1rpc.io/arb"
+  ]
+};
+var FEE_BPS = 28;
+var SWAP_TOPIC0 = "0xd6d34547c69c5ee3d2667625c188acf1006abb93e0ee7cf03925c67cf7760413";
+var SURPLUS_TOPIC0 = "0x1a3afef0f067eb51a6bfec6ab3625a4408dd8c3571b72836483e68feb70d1026";
+
+// src/resilience.ts
+var INFLIGHT = /* @__PURE__ */ new Map();
+var MEM = /* @__PURE__ */ new Map();
+async function singleflight(key, fn) {
+  const existing = INFLIGHT.get(key);
+  if (existing) return existing;
+  const flight = fn();
+  INFLIGHT.set(key, flight);
+  try {
+    return await flight;
+  } finally {
+    INFLIGHT.delete(key);
+  }
+}
+function memGet(key, ttlMs, now = Date.now()) {
+  if (ttlMs <= 0) return void 0;
+  const hit = MEM.get(key);
+  return hit && now - hit.at < ttlMs ? hit.data : void 0;
+}
+function memPut(key, data, now = Date.now()) {
+  MEM.set(key, { at: now, data });
+  if (MEM.size > 500) {
+    const oldest = MEM.keys().next().value;
+    if (oldest !== void 0) MEM.delete(oldest);
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function retryDelayMs(res, attempt, base) {
+  const ra = Number(res?.headers.get("retry-after"));
+  if (Number.isFinite(ra) && ra > 0) return Math.min(1e4, ra * 1e3);
+  return base * 3 ** attempt + Math.floor(Math.random() * base);
+}
+function isTransient(res) {
+  return !res || res.status === 429 || res.status === 502 || res.status === 503 || res.status === 504;
+}
+async function resilientFetch(fetchFn, url, init, opts = {}) {
+  const { retries = 2, backoffMs = 250, timeoutMs = 15e3 } = opts;
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    let res;
+    try {
+      res = await fetchFn(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+      if (!isTransient(res)) return res;
+      if (attempt === retries) return res;
+    } catch (e) {
+      lastErr = e;
+      if (attempt === retries) throw e;
+    }
+    await sleep(retryDelayMs(res, attempt, backoffMs));
+  }
+  throw lastErr instanceof Error ? lastErr : new Error("request failed");
+}
+
+// src/client.ts
+var BlazeApiError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.name = "BlazeApiError";
+    this.code = code;
+    this.status = status;
+  }
+};
+function toSearch(req) {
+  const sp = new URLSearchParams();
+  sp.set("chain", String(resolveChain(req.chain)));
+  sp.set("in", req.tokenIn.trim());
+  sp.set("out", req.tokenOut.trim());
+  sp.set("amountIn", typeof req.amountIn === "bigint" ? req.amountIn.toString() : String(req.amountIn).trim());
+  if (req.recipient) sp.set("recipient", req.recipient);
+  if (req.slippageBps !== void 0) sp.set("slippageBps", String(req.slippageBps));
+  if (req.deadlineSec !== void 0) sp.set("deadlineSec", String(req.deadlineSec));
+  if (req.exact) sp.set("exact", "1");
+  return sp;
+}
+var BlazePhoenix = class {
+  base;
+  fetchFn;
+  timeoutMs;
+  retries;
+  cacheTtlMs;
+  constructor(opts = {}) {
+    this.base = (opts.baseUrl ?? API_BASE).replace(/\/+$/, "");
+    this.fetchFn = opts.fetchFn ?? globalThis.fetch;
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.retries = opts.retries ?? 2;
+    this.cacheTtlMs = opts.cacheTtlMs ?? 1e3;
+    if (!this.fetchFn) throw new Error("No fetch available \u2014 Node >= 18 required (or pass fetchFn)");
+  }
+  /** Build the GET /api/quote URL for a request (useful for logging/debugging). */
+  quoteUrl(req) {
+    return `${this.base}/api/quote?${toSearch(req).toString()}`;
+  }
+  async call(path, init) {
+    const res = await resilientFetch(this.fetchFn, `${this.base}${path}`, init, {
+      retries: this.retries,
+      timeoutMs: this.timeoutMs
+    });
+    const body = await res.json().catch(() => null);
+    if (!body || typeof body !== "object") {
+      throw new BlazeApiError("bad_response", `non-JSON response (HTTP ${res.status})`, res.status);
+    }
+    if ("ok" in body && body.ok === false) {
+      throw new BlazeApiError(body.code ?? "error", body.error ?? "request failed", res.status);
+    }
+    return body;
+  }
+  /** One quote — previewPlan computed on-chain. Throws BlazeApiError on failure.
+   *  Identical concurrent calls share one request; preview quotes ride a tiny
+   *  micro-cache (cacheTtlMs) so hot loops never hammer the wire. */
+  async quote(req) {
+    const qs = toSearch(req).toString();
+    const key = `Q ${this.base}?${qs}`;
+    const cacheable = !req.recipient && !req.exact && this.cacheTtlMs > 0;
+    if (cacheable) {
+      const hit = memGet(key, this.cacheTtlMs);
+      if (hit) return hit;
+    }
+    const q = await singleflight(key, () => this.call(`/api/quote?${qs}`));
+    if (cacheable) memPut(key, q);
+    return q;
+  }
+  /** Up to 10 quotes in one round-trip (screeners / arb loops).
+   *  Per-item failures come back inline — the batch itself only throws on
+   *  transport/validation errors. Identical concurrent batches coalesce. */
+  quoteBatch(reqs) {
+    const body = JSON.stringify({
+      requests: reqs.map((r) => Object.fromEntries(toSearch(r).entries()))
+    });
+    return singleflight(`B ${this.base} ${body}`, () => this.call("/api/quote/batch", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body
+    }));
+  }
+  /** Service health + per-chain live flags. Zero upstream cost server-side —
+   *  poll it from your monitor as often as you like. */
+  health() {
+    return this.call("/api/health");
+  }
+  /** Machine-readable protocol manifest — near-static, cached for 1h. */
+  async manifest() {
+    const key = `M ${this.base}`;
+    const hit = memGet(key, 36e5);
+    if (hit) return hit;
+    const m = await singleflight(key, () => this.call("/api/manifest"));
+    memPut(key, m);
+    return m;
+  }
+};
+function pollQuote(client, req, onQuote, opts = {}) {
+  const interval = Math.max(500, opts.intervalMs ?? 4e3);
+  let stopped = false;
+  let busy = false;
+  const tick = async () => {
+    if (stopped || busy) return;
+    busy = true;
+    try {
+      const q = await client.quote(req);
+      if (!stopped) onQuote(q);
+    } catch (e) {
+      if (!stopped) opts.onError?.(e);
+    } finally {
+      busy = false;
+    }
+  };
+  void tick();
+  const timer = setInterval(() => {
+    void tick();
+  }, interval);
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+function buildSwapTx(q) {
+  if (q.tx) return q.tx;
+  if (q.wrapRequired) {
+    throw new Error("native ETH input: wrap to WETH first (WETH.deposit), then re-quote with in=WETH");
+  }
+  throw new Error("no tx in quote \u2014 pass `recipient` in the request (and check quote.canExecute)");
+}
+function deepLink(opts = {}) {
+  const base = (opts.baseUrl ?? API_BASE).replace(/\/+$/, "");
+  const sp = new URLSearchParams();
+  sp.set("tab", opts.tab ?? "swap");
+  if (opts.chain !== void 0) sp.set("chain", String(resolveChain(opts.chain)));
+  if (opts.tokenIn) sp.set("in", opts.tokenIn);
+  if (opts.tokenOut) sp.set("out", opts.tokenOut);
+  if (opts.amount) sp.set("amt", opts.amount);
+  return `${base}/?${sp.toString()}`;
+}
+
+// src/abis.ts
+var LEG_COMPONENTS = [
+  { name: "pool", type: "address" },
+  { name: "hooks", type: "address" },
+  { name: "kind", type: "uint8" },
+  { name: "fee", type: "uint24" },
+  { name: "tickSpacing", type: "int24" },
+  { name: "zeroForOne", type: "bool" },
+  { name: "stable", type: "bool" },
+  { name: "amountIn", type: "uint256" },
+  { name: "expectedOut", type: "uint256" },
+  { name: "auxId", type: "bytes32" }
+];
+var HOP_COMPONENTS = [
+  { name: "tokenIn", type: "address" },
+  { name: "tokenOut", type: "address" },
+  { name: "amountIn", type: "uint256" },
+  { name: "expectedOut", type: "uint256" },
+  { name: "legs", type: "tuple[]", components: LEG_COMPONENTS }
+];
+var ROUTE_COMPONENTS = [
+  { name: "hops", type: "tuple[]", components: HOP_COMPONENTS },
+  { name: "totalOut", type: "uint256" },
+  { name: "singleOut", type: "uint256" },
+  { name: "singleOutFloor", type: "uint256" },
+  { name: "expectedImpactBps", type: "uint256" },
+  { name: "confidenceWad", type: "uint256" },
+  { name: "estGas", type: "uint256" },
+  { name: "hasSurplus", type: "bool" },
+  { name: "isV4Bundle", type: "bool" }
+];
+var PREVIEW_COMPONENTS = [
+  { name: "route", type: "tuple", components: ROUTE_COMPONENTS },
+  { name: "grossOut", type: "uint256" },
+  { name: "protocolFee", type: "uint256" },
+  { name: "safetyBuffer", type: "uint256" },
+  { name: "netOut", type: "uint256" },
+  { name: "ironFloor", type: "uint256" },
+  { name: "userMinOut", type: "uint256" },
+  { name: "effectiveMinOut", type: "uint256" },
+  { name: "estGas", type: "uint256" },
+  { name: "hops", type: "uint256" },
+  { name: "legs", type: "uint256" },
+  { name: "topology", type: "uint8" },
+  { name: "bridgeUsed", type: "address" },
+  { name: "canExecute", type: "bool" }
+];
+var QUOTER_ABI = [
+  {
+    type: "function",
+    name: "previewPlan",
+    stateMutability: "view",
+    inputs: [
+      { name: "tIn", type: "address" },
+      { name: "tOut", type: "address" },
+      { name: "amountIn", type: "uint256" }
+    ],
+    outputs: [
+      { name: "pv", type: "tuple", components: PREVIEW_COMPONENTS },
+      { name: "fallbackRoute", type: "tuple", components: ROUTE_COMPONENTS },
+      { name: "hasFallback", type: "bool" }
+    ]
+  },
+  {
+    type: "function",
+    name: "previewPlanExact",
+    stateMutability: "view",
+    inputs: [
+      { name: "tIn", type: "address" },
+      { name: "tOut", type: "address" },
+      { name: "amountIn", type: "uint256" }
+    ],
+    outputs: [
+      { name: "route", type: "tuple", components: ROUTE_COMPONENTS },
+      { name: "exactOut", type: "uint256" }
+    ]
+  }
+];
+var ROUTER_ABI = [
+  {
+    type: "function",
+    name: "swapExactIn",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "route", type: "tuple", components: ROUTE_COMPONENTS },
+      { name: "amountIn", type: "uint256" },
+      { name: "userMinOut", type: "uint256" },
+      { name: "recipient", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  },
+  {
+    type: "event",
+    name: "Swap",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "tokenIn", type: "address", indexed: true },
+      { name: "tokenOut", type: "address", indexed: true },
+      { name: "amountIn", type: "uint256", indexed: false },
+      { name: "amountOut", type: "uint256", indexed: false },
+      { name: "legs", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Surplus",
+    inputs: [
+      { name: "token", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/erc20.ts
+var MAX_UINT256 = (1n << 256n) - 1n;
+var HEX_ADDR = /^0x[0-9a-fA-F]{40}$/;
+var APPROVE_SELECTOR = "0x095ea7b3";
+function pad32(hexNo0x) {
+  return hexNo0x.padStart(64, "0");
+}
+function buildApproveTx(opts) {
+  const chainId = resolveChain(opts.chain);
+  const spender = opts.spender ?? CHAINS[chainId].contracts.router;
+  if (!HEX_ADDR.test(opts.token)) throw new Error(`invalid token address: ${opts.token}`);
+  if (!HEX_ADDR.test(spender)) throw new Error(`invalid spender address: ${spender}`);
+  if (opts.amount < 0n || opts.amount > MAX_UINT256) throw new Error("amount out of uint256 range");
+  const data = APPROVE_SELECTOR + pad32(spender.slice(2).toLowerCase()) + pad32(opts.amount.toString(16));
+  return { to: opts.token, data, value: "0" };
+}
+function toBaseUnits(amount, decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 77) {
+    throw new Error(`invalid decimals: ${decimals}`);
+  }
+  const s = amount.trim();
+  const m = /^(\d+)(?:\.(\d+))?$/.exec(s);
+  if (!m) throw new Error(`invalid amount: "${amount}" (use e.g. "1.5")`);
+  const [, whole, frac = ""] = m;
+  if (frac.length > decimals) {
+    throw new Error(`"${amount}" has ${frac.length} fractional digits \u2014 token only carries ${decimals}`);
+  }
+  return BigInt(whole) * 10n ** BigInt(decimals) + BigInt(frac.padEnd(decimals, "0") || "0");
+}
+function fromBaseUnits(v, decimals, maxDp) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 77) {
+    throw new Error(`invalid decimals: ${decimals}`);
+  }
+  const n = typeof v === "bigint" ? v : BigInt(v);
+  const neg = n < 0n;
+  const abs = neg ? -n : n;
+  const base = 10n ** BigInt(decimals);
+  const whole = abs / base;
+  let frac = (abs % base).toString().padStart(decimals, "0");
+  if (maxDp !== void 0) frac = frac.slice(0, Math.max(0, maxDp));
+  frac = frac.replace(/0+$/, "");
+  return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
+}
+
+// src/onchain.ts
+async function loadViem() {
+  try {
+    return await import('viem');
+  } catch {
+    throw new Error("this feature needs the optional peer dependency 'viem' \u2014 npm i viem");
+  }
+}
+async function transportFor(chainId, rpcUrl) {
+  const { http, fallback } = await loadViem();
+  return rpcUrl ? http(rpcUrl) : fallback(PUBLIC_RPCS[chainId].map((u) => http(u)));
+}
+async function quoteOnChain(opts) {
+  const { createPublicClient } = await loadViem();
+  const chainId = resolveChain(opts.chain);
+  const client = createPublicClient({ transport: await transportFor(chainId, opts.rpcUrl) });
+  const [pv, , hasFallback] = await client.readContract({
+    address: CHAINS[chainId].contracts.quoter,
+    abi: QUOTER_ABI,
+    functionName: "previewPlan",
+    args: [opts.tokenIn, opts.tokenOut, opts.amountIn]
+  });
+  return { preview: pv, hasFallback, chainId };
+}
+async function watchFills(opts) {
+  const { createPublicClient, parseAbiItem } = await loadViem();
+  const chainId = resolveChain(opts.chain);
+  const client = createPublicClient({ transport: await transportFor(chainId, opts.rpcUrl) });
+  return client.watchEvent({
+    address: CHAINS[chainId].contracts.router,
+    event: parseAbiItem(
+      "event Swap(address indexed user, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut, uint256 legs)"
+    ),
+    pollingInterval: opts.pollMs ?? 4e3,
+    onLogs: (logs) => {
+      for (const log of logs) {
+        const a = log.args;
+        opts.onFill({
+          txHash: log.transactionHash,
+          blockNumber: log.blockNumber ?? 0n,
+          user: a.user,
+          tokenIn: a.tokenIn,
+          tokenOut: a.tokenOut,
+          amountIn: a.amountIn,
+          amountOut: a.amountOut,
+          legs: a.legs
+        });
+      }
+    }
+  });
+}
+async function getFills(opts) {
+  const { createPublicClient, parseAbiItem } = await loadViem();
+  const chainId = resolveChain(opts.chain);
+  const client = createPublicClient({ transport: await transportFor(chainId, opts.rpcUrl) });
+  const logs = await client.getLogs({
+    address: CHAINS[chainId].contracts.router,
+    event: parseAbiItem(
+      "event Swap(address indexed user, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut, uint256 legs)"
+    ),
+    fromBlock: opts.fromBlock,
+    toBlock: opts.toBlock
+  });
+  return logs.map((log) => {
+    const a = log.args;
+    return {
+      txHash: log.transactionHash,
+      blockNumber: log.blockNumber ?? 0n,
+      user: a.user,
+      tokenIn: a.tokenIn,
+      tokenOut: a.tokenOut,
+      amountIn: a.amountIn,
+      amountOut: a.amountOut,
+      legs: a.legs
+    };
+  });
+}
+
+exports.API_BASE = API_BASE;
+exports.BlazeApiError = BlazeApiError;
+exports.BlazePhoenix = BlazePhoenix;
+exports.CHAINS = CHAINS;
+exports.FEE_BPS = FEE_BPS;
+exports.MAX_UINT256 = MAX_UINT256;
+exports.PUBLIC_RPCS = PUBLIC_RPCS;
+exports.QUOTER_ABI = QUOTER_ABI;
+exports.ROUTER_ABI = ROUTER_ABI;
+exports.SURPLUS_TOPIC0 = SURPLUS_TOPIC0;
+exports.SWAP_TOPIC0 = SWAP_TOPIC0;
+exports.buildApproveTx = buildApproveTx;
+exports.buildSwapTx = buildSwapTx;
+exports.deepLink = deepLink;
+exports.fromBaseUnits = fromBaseUnits;
+exports.getFills = getFills;
+exports.pollQuote = pollQuote;
+exports.quoteOnChain = quoteOnChain;
+exports.resilientFetch = resilientFetch;
+exports.resolveChain = resolveChain;
+exports.singleflight = singleflight;
+exports.toBaseUnits = toBaseUnits;
+exports.watchFills = watchFills;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map