@peachprojects/aggregator-sdk 0.0.0-experimental-20260324105259

package/dist/index.mjs

@@ -0,0 +1,1098 @@
+import { ethers as h } from "ethers";
+const X = 50, y = 10000n, T = 1200, D = 6e4, x = [50, 100, 200, 400, 800, 1200], V = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+function O(m) {
+  return m.toLowerCase() === V.toLowerCase();
+}
+const tt = 4001;
+var g = /* @__PURE__ */ ((m) => (m.PancakeV2 = "PancakeV2", m.PancakeV3 = "PancakeV3", m.UniswapV3 = "UniswapV3", m.Dodo = "Dodo", m.Thena = "Thena", m))(g || {});
+const et = {
+  chainId: 56,
+  rpcUrl: "https://bsc-dataseed.binance.org",
+  weth: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+  // WBNB
+  adapters: []
+}, nt = {
+  chainId: 97,
+  rpcUrl: "https://bsc-testnet-rpc.publicnode.com",
+  weth: "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
+  // WBNB Testnet
+  adapters: []
+};
+class $ extends Error {
+  constructor(t, e, n) {
+    super(t), this.name = "ExecuteTimeoutError", this.stage = e, this.txHash = n;
+  }
+}
+const k = {
+  /** Default route search depth */
+  depth: 3,
+  /** Default trade split count */
+  splitCount: 20,
+  /** Default DEX providers */
+  providers: ["PANCAKEV2", "PANCAKEV3", "UNISWAPV3", "DODO", "THENA"],
+  /** Default client version for V3 API */
+  clientVersion: 1001500
+}, M = 1e4;
+class U {
+  constructor(t) {
+    if (!t.baseUrl)
+      throw new Error("ApiClient requires a baseUrl");
+    this.baseUrl = t.baseUrl, this.timeout = t.timeout || M;
+  }
+  /**
+   * Find optimal routes via API
+   */
+  async findRoutes(t) {
+    const {
+      from: e,
+      target: n,
+      amount: o,
+      byAmountIn: s = !0,
+      depth: r = k.depth,
+      splitCount: a = k.splitCount,
+      providers: i = k.providers
+    } = t, c = new URLSearchParams({
+      from: e,
+      target: n,
+      amount: o.toString(),
+      by_amount_in: s.toString(),
+      depth: r.toString(),
+      split_count: a.toString(),
+      providers: i.join(","),
+      v: k.clientVersion.toString()
+    }), u = `${this.baseUrl}/router/find_routes?${c}`, d = new AbortController(), l = setTimeout(() => d.abort(), this.timeout);
+    try {
+      const f = await fetch(u, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        },
+        signal: d.signal
+      });
+      if (clearTimeout(l), !f.ok)
+        throw new w(
+          `API request failed: ${f.status} ${f.statusText}`,
+          f.status
+        );
+      const v = await f.json();
+      if (v.code !== 200)
+        throw new w(v.msg || "Route not found", v.code);
+      if (!v.data || !v.data.paths || v.data.paths.length === 0)
+        throw new w("No routes found", 404);
+      return v.data;
+    } catch (f) {
+      throw clearTimeout(l), f instanceof w ? f : f instanceof Error ? f.name === "AbortError" ? new w("API request timeout", 408) : new w(`API request failed: ${f.message}`, 0) : new w("Unknown API error", 0);
+    }
+  }
+  /**
+   * Get service status including available providers
+   */
+  async getStatus() {
+    const t = `${this.baseUrl}/router/status`, e = new AbortController(), n = setTimeout(() => e.abort(), this.timeout);
+    try {
+      const o = await fetch(t, {
+        method: "GET",
+        headers: {
+          Accept: "application/json"
+        },
+        signal: e.signal
+      });
+      if (clearTimeout(n), !o.ok)
+        throw new w(
+          `API request failed: ${o.status} ${o.statusText}`,
+          o.status
+        );
+      const s = await o.json();
+      if (s.code !== 200)
+        throw new w(s.msg || "Failed to get status", s.code);
+      return s.data;
+    } catch (o) {
+      throw clearTimeout(n), o instanceof w ? o : o instanceof Error ? o.name === "AbortError" ? new w("API request timeout", 408) : new w(`API request failed: ${o.message}`, 0) : new w("Unknown API error", 0);
+    }
+  }
+  /**
+   * Get list of available providers
+   */
+  async getAvailableProviders() {
+    return (await this.getStatus()).providers;
+  }
+  /**
+   * Update API base URL
+   */
+  setBaseUrl(t) {
+    this.baseUrl = t;
+  }
+  /**
+   * Get current API base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+}
+class w extends Error {
+  constructor(t, e) {
+    super(t), this.name = "ApiError", this.code = e;
+  }
+}
+async function b(m, t = D) {
+  if (t <= 0)
+    return m;
+  let e;
+  try {
+    return await Promise.race([
+      m,
+      new Promise((n, o) => {
+        e = setTimeout(() => {
+          o(
+            new $(
+              `Wallet did not settle sendTransaction within ${t}ms.`,
+              "wallet_send"
+            )
+          );
+        }, t);
+      })
+    ]);
+  } finally {
+    e && clearTimeout(e);
+  }
+}
+const B = [
+  "function swap((address srcToken, address dstToken, uint256 amountIn, uint256 amountOutMin, (address adapter, address pool, address tokenIn, address tokenOut, uint256 amountIn, bytes extraData)[] steps, address[] intermediateTokens, uint256 deadline, bytes32 quoteId, uint256 expectAmountOut) params) external returns (uint256 amountOut)",
+  "function swapETH((address srcToken, address dstToken, uint256 amountIn, uint256 amountOutMin, (address adapter, address pool, address tokenIn, address tokenOut, uint256 amountIn, bytes extraData)[] steps, address[] intermediateTokens, uint256 deadline, bytes32 quoteId, uint256 expectAmountOut) params) external payable returns (uint256 amountOut)",
+  "function isAdapterRegistered(address adapter) external view returns (bool)",
+  "function WETH() external view returns (address)"
+], E = [
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function allowance(address owner, address spender) external view returns (uint256)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function decimals() external view returns (uint8)",
+  "function symbol() external view returns (string)"
+], R = {
+  PANCAKEV3: g.PancakeV3,
+  PANCAKEV2: g.PancakeV2,
+  UNISWAPV3: g.UniswapV3,
+  DODO: g.Dodo,
+  THENA: g.Thena
+};
+class ot {
+  constructor(t, e, n) {
+    this.config = t, this.provider = e || new h.JsonRpcProvider(t.rpcUrl), this.routerContract = new h.Contract(
+      t.routerAddress || h.ZeroAddress,
+      B,
+      this.provider
+    ), this.apiClient = n?.api ? new U(n.api) : null;
+  }
+  /**
+   * Get the effective router address for a quote.
+   */
+  getRouterAddress(t) {
+    const e = t.routerAddress || this.config.routerAddress;
+    if (!e || e === h.ZeroAddress)
+      throw new Error("No router address available. Provide routerAddress in config or use API-based getQuote.");
+    return e;
+  }
+  /**
+   * Apply slippage to swap params, returning a new SwapParams with adjusted amountOutMin
+   */
+  applySlippage(t, e) {
+    if (e < 0 || e > 1e4)
+      throw new Error("slippageBps must be between 0 and 10000");
+    const n = t.amountOutMin * (y - BigInt(e)) / y;
+    return { ...t, amountOutMin: n };
+  }
+  /**
+   * Build transaction requests for an approval (if needed) and the swap itself.
+   */
+  async swap(t, e, n) {
+    const o = this.getRouterAddress(t), { tx: s, method: r } = this.buildSwapTransactionRequest(t, n);
+    let a;
+    return t.srcNative || (a = await this.buildApprovalRequest(
+      t.srcToken,
+      e,
+      t.amountIn,
+      o,
+      n
+    )), {
+      routerAddress: o,
+      method: r,
+      tx: s,
+      approval: a
+    };
+  }
+  /**
+   * Execute swap using the legacy signer-managed flow.
+   *
+   * @deprecated Prefer swap(), then send the returned tx request with your wallet/client.
+   */
+  async execute(t, e, n) {
+    const o = await e.getAddress(), s = await this.swap(t, o, n);
+    try {
+      return s.approval && await (await this.sendTransactionWithTimeout(
+        e,
+        s.approval.tx,
+        n
+      )).wait(), await this.sendTransactionWithTimeout(e, s.tx, n);
+    } catch (r) {
+      const a = r instanceof Error ? r.message : String(r), i = /estimateGas/i.test(a), c = /missing revert data/i.test(a) || a.includes("reason=null") && a.includes("data=null");
+      if (i && (c || /reason=null|data=null/.test(a))) {
+        const u = "Transaction reverted during gas estimation and the RPC did not return a revert reason. Try: 1) Get a fresh quote and confirm immediately 2) Switch network or RPC 3) Increase slippage.", d = new Error(`${u} (estimateGas/missing revert data)`);
+        throw d.cause = r, d;
+      }
+      throw r;
+    }
+  }
+  /**
+   * Encode parameters to contract format
+   */
+  encodeParams(t) {
+    return {
+      srcToken: t.srcToken,
+      dstToken: t.dstToken,
+      amountIn: t.amountIn,
+      amountOutMin: t.amountOutMin,
+      steps: t.steps.map((e) => ({
+        adapter: e.adapter,
+        pool: e.pool,
+        tokenIn: e.tokenIn,
+        tokenOut: e.tokenOut,
+        amountIn: e.amountIn,
+        extraData: e.extraData
+      })),
+      intermediateTokens: t.intermediateTokens,
+      deadline: t.deadline,
+      quoteId: t.quoteId,
+      expectAmountOut: t.expectAmountOut
+    };
+  }
+  getProtocolForProvider(t) {
+    if (t in R)
+      return R[t];
+    throw new Error(`Unsupported provider: ${t}`);
+  }
+  /**
+   * Encode swap calldata for the Peach Aggregator contract
+   * Useful for simulation or building custom transactions
+   *
+   * @param quote - Quote object from getQuote
+   * @param slippageBps - Slippage tolerance in basis points (e.g. 50 = 0.5%). Required.
+   * @returns Encoded calldata and transaction info (to address, value)
+   */
+  encodeSwapCalldata(t, e) {
+    const n = t.routerAddress ?? this.config.routerAddress ?? this.routerContract.target, o = this.applySlippage(t.params, e), s = t.srcNative === !0, r = this.encodeParams(o);
+    if (s) {
+      const a = this.routerContract.interface.encodeFunctionData("swapETH", [r]);
+      return {
+        to: n,
+        data: a,
+        value: t.amountIn,
+        method: "swapETH"
+      };
+    } else {
+      const a = this.routerContract.interface.encodeFunctionData("swap", [r]);
+      return {
+        to: n,
+        data: a,
+        value: 0n,
+        method: "swap"
+      };
+    }
+  }
+  buildSwapTransactionRequest(t, e) {
+    const { to: n, data: o, value: s, method: r } = this.encodeSwapCalldata(t, e.slippageBps);
+    return {
+      method: r,
+      tx: this.applyTxOverrides({ to: n, data: o, value: s }, e, !0)
+    };
+  }
+  async buildApprovalRequest(t, e, n, o, s) {
+    const r = await this.getAllowance(t, e, o);
+    if (!(r >= n))
+      return {
+        token: t,
+        owner: e,
+        spender: o,
+        currentAllowance: r,
+        requiredAmount: n,
+        approveAmount: h.MaxUint256,
+        tx: this.buildApprovalTransactionRequest(t, o, s)
+      };
+  }
+  buildApprovalTransactionRequest(t, e, n) {
+    const s = new h.Interface(E).encodeFunctionData("approve", [e, h.MaxUint256]);
+    return this.applyTxOverrides({ to: t, data: s, value: 0n }, n, !1);
+  }
+  async getAllowance(t, e, n) {
+    return new h.Contract(t, E, this.provider).allowance(e, n);
+  }
+  applyTxOverrides(t, e, n) {
+    const o = { ...t };
+    return e.gasPrice && (o.gasPrice = e.gasPrice), n && e.gasLimit && (o.gasLimit = e.gasLimit), o;
+  }
+  async sendTransactionWithTimeout(t, e, n) {
+    const o = n.timeoutMs ?? D;
+    if (o <= 0)
+      return t.sendTransaction(e);
+    const s = t;
+    if (typeof s.sendUncheckedTransaction == "function" && s.provider) {
+      const r = await b(
+        s.sendUncheckedTransaction(e),
+        o
+      ), a = await this.waitForTransactionResponse(
+        s.provider,
+        r,
+        o,
+        n.transactionResponsePollingIntervalsMs
+      );
+      if (a.response)
+        return a.response;
+      const i = a.rpcErrors > 0 ? `${a.rpcErrors} transient provider error(s) and ${a.nullResponses} null response(s)` : `${a.nullResponses} null response(s)`;
+      throw new $(
+        `Transaction was broadcast but provider did not return TransactionResponse within ${o}ms (${i}).`,
+        "provider_index",
+        r
+      );
+    }
+    return b(t.sendTransaction(e), o);
+  }
+  async waitForTransactionResponse(t, e, n, o = x) {
+    const s = Date.now() + n;
+    let r = 0, a = 0, i = 0;
+    for (; Date.now() < s; ) {
+      try {
+        const u = await t.getTransaction(e);
+        if (u)
+          return { response: u, nullResponses: a, rpcErrors: i };
+        a++;
+      } catch {
+        i++;
+      }
+      const c = this.getNextPollingDelay(o, r);
+      r++, await this.delay(Math.min(c, Math.max(25, s - Date.now())));
+    }
+    return { response: null, nullResponses: a, rpcErrors: i };
+  }
+  async delay(t) {
+    t <= 0 || await new Promise((e) => {
+      setTimeout(e, t);
+    });
+  }
+  getNextPollingDelay(t, e) {
+    return t.length === 0 ? x.at(-1) ?? 1200 : t[Math.min(e, t.length - 1)] ?? 1200;
+  }
+  /**
+   * Get token metadata and, optionally, the balance for a specific owner.
+   */
+  async getTokenInfo(t, e) {
+    const n = new h.Contract(t, E, this.provider), [o, s, r] = await Promise.all([
+      n.symbol(),
+      n.decimals(),
+      e ? n.balanceOf(e) : Promise.resolve(void 0)
+    ]);
+    return r === void 0 ? { symbol: o, decimals: s } : { symbol: o, decimals: s, balance: r };
+  }
+  /**
+   * Get user token balance
+   */
+  async getBalance(t, e) {
+    return new h.Contract(t, E, this.provider).balanceOf(e);
+  }
+  /**
+   * Get quote via API
+   * @throws Error if API client is not configured
+   */
+  async getQuote(t) {
+    const { srcToken: e, dstToken: n, amountIn: o, options: s = {} } = t, {
+      byAmountIn: r = !0,
+      depth: a = k.depth,
+      splitCount: i = k.splitCount,
+      providers: c = k.providers,
+      deadlineSeconds: u = T
+    } = s;
+    if (!this.apiClient)
+      throw new Error("API client is not configured. getQuote() requires PeachClientOptions.api.");
+    const d = O(e), l = O(n), f = d ? this.config.weth : e, v = l ? this.config.weth : n, I = await this.apiClient.findRoutes({
+      from: f,
+      target: v,
+      amount: o,
+      byAmountIn: r,
+      depth: a,
+      splitCount: i,
+      providers: c
+    });
+    return this.buildQuoteFromApi(I, f, v, u, c, d, l);
+  }
+  /**
+   * Filter paths by allowed providers, removing paths with disallowed providers
+   * and cascade-removing orphaned paths that depend on removed paths.
+   */
+  filterPathsByProviders(t, e, n, o) {
+    const s = new Set(e.map((l) => l.toUpperCase()));
+    let r = t.filter((l) => s.has(l.provider.toUpperCase()));
+    if (r.length === t.length)
+      return r;
+    const a = n.toLowerCase(), i = o.toLowerCase(), c = /* @__PURE__ */ new Set();
+    c.add(a);
+    let u = !0;
+    for (; u; ) {
+      u = !1;
+      for (const l of r)
+        c.has(l.token_in.toLowerCase()) && !c.has(l.token_out.toLowerCase()) && (c.add(l.token_out.toLowerCase()), u = !0);
+    }
+    const d = /* @__PURE__ */ new Set();
+    for (d.add(i), u = !0; u; ) {
+      u = !1;
+      for (const l of r)
+        d.has(l.token_out.toLowerCase()) && !d.has(l.token_in.toLowerCase()) && (d.add(l.token_in.toLowerCase()), u = !0);
+    }
+    return r.length, r = r.filter(
+      (l) => c.has(l.token_in.toLowerCase()) && d.has(l.token_out.toLowerCase())
+    ), r;
+  }
+  /**
+   * Build Quote from route data (e.g. from JSON file or API response).
+   * Use this to simulate a swap from a pre-computed route without calling the API.
+   *
+   * @param data - Route data with paths, amount_in, amount_out, contracts, gas
+   * @param srcToken - Source token address (first path token_in)
+   * @param dstToken - Destination token address (last path token_out)
+   * @param deadlineSeconds - Optional deadline in seconds from now (default: 20 min)
+   */
+  buildQuoteFromRouteData(t, e, n, o, s) {
+    const r = this.buildQuoteFromRouteDataInternal(
+      t,
+      e,
+      n,
+      o ?? T,
+      void 0
+    );
+    return s?.srcNative && (r.srcNative = !0), s?.dstNative && (r.dstNative = !0), r;
+  }
+  /**
+   * Build Quote from API response
+   */
+  buildQuoteFromApi(t, e, n, o, s, r, a) {
+    const i = this.buildQuoteFromRouteDataInternal(
+      t,
+      e,
+      n,
+      o,
+      s
+    );
+    return r && (i.srcNative = !0), a && (i.dstNative = !0), i;
+  }
+  buildQuoteFromRouteDataInternal(t, e, n, o, s) {
+    const r = e.toLowerCase();
+    t.paths.length;
+    let a = t.paths.filter((p) => !(!(p.token_in.toLowerCase() === r) && BigInt(p.amount_in) === 0n && BigInt(p.amount_out) === 0n));
+    if (a.length === 0)
+      throw new w("All route paths have zero amounts", 4001);
+    if (s && s.length > 0 && (a = this.filterPathsByProviders(a, s, e, n), a.length === 0))
+      throw new w("No valid route paths remaining after provider filtering", 4001);
+    const i = n.toLowerCase();
+    let c = 0n, u = 0n;
+    for (const p of a)
+      p.token_in.toLowerCase() === r && (c += BigInt(p.amount_in)), p.token_out.toLowerCase() === i && (u += BigInt(p.amount_out));
+    const d = BigInt(
+      Math.floor(Date.now() / 1e3) + o
+    ), l = /* @__PURE__ */ new Map();
+    for (const p of a) {
+      const A = p.token_in.toLowerCase();
+      l.set(A, (l.get(A) ?? 0) + 1);
+    }
+    const f = /* @__PURE__ */ new Map(), v = a.map((p) => {
+      const A = p.token_in.toLowerCase(), _ = (f.get(A) ?? 0) + 1;
+      f.set(A, _);
+      const S = l.get(A), L = S > 1 && _ < S, N = A === r;
+      return {
+        adapter: p.adapter,
+        pool: p.pool,
+        tokenIn: p.token_in,
+        tokenOut: p.token_out,
+        amountIn: N || L ? BigInt(p.amount_in) : 0n,
+        extraData: p.extra_data || "0x"
+      };
+    }), I = /* @__PURE__ */ new Set();
+    for (const p of a)
+      p.token_out.toLowerCase() !== i && I.add(p.token_out);
+    const P = Array.from(I), C = {
+      srcToken: e,
+      dstToken: n,
+      amountIn: c,
+      amountOutMin: u,
+      steps: v,
+      intermediateTokens: P,
+      deadline: d,
+      quoteId: t.request_id ? h.id(t.request_id).slice(0, 66) : h.ZeroHash,
+      expectAmountOut: u
+    }, F = {
+      routes: [
+        {
+          steps: a.map((p) => ({
+            pool: {
+              address: p.pool,
+              token0: p.token_in,
+              token1: p.token_out,
+              protocol: this.getProtocolForProvider(p.provider),
+              fee: p.fee_rate ? Math.round(parseFloat(p.fee_rate) * 1e6) : void 0
+            },
+            tokenIn: p.token_in,
+            tokenOut: p.token_out,
+            amountIn: BigInt(p.amount_in),
+            amountOut: BigInt(p.amount_out)
+          })),
+          amountIn: c,
+          amountOut: u,
+          gasEstimate: BigInt(t.gas)
+        }
+      ],
+      percentages: [1e4],
+      totalAmountIn: c,
+      totalAmountOut: u,
+      totalGasEstimate: BigInt(t.gas)
+    };
+    if (!t.contracts?.router)
+      throw new w("API response missing contracts.router address", 4002);
+    return {
+      srcToken: e,
+      dstToken: n,
+      amountIn: c,
+      amountOut: u,
+      priceImpact: parseFloat(t.deviation_ratio || "0"),
+      route: F,
+      params: C,
+      gasEstimate: BigInt(t.gas),
+      routerAddress: t.contracts?.router
+    };
+  }
+  /**
+   * Get available providers from the API
+   * @throws Error if API client is not configured
+   */
+  async getAvailableProviders() {
+    if (!this.apiClient)
+      throw new Error("API client is not configured. getAvailableProviders() requires PeachClientOptions.api.");
+    return this.apiClient.getAvailableProviders();
+  }
+  /**
+   * Simulate swap via eth_call (no gas, no state change)
+   * Useful for testing and verifying quote accuracy
+   *
+   * @param quote - Quote object from getQuote
+   * @param slippageBps - Slippage tolerance in basis points (e.g. 50 = 0.5%). Required.
+   * @param fromAddress - Optional caller address for simulation (default: zero address)
+   * @param stateOverrides - Optional state overrides for ERC20 balance/allowance
+   * @returns Simulated amountOut and method used
+   */
+  async simulate(t, e, n, o) {
+    const s = n || h.ZeroAddress, { to: r, data: a, value: i, method: c } = this.encodeSwapCalldata(t, e);
+    if (console.log("[PeachClient] simulate using router:", r), o) {
+      const u = this.getJsonRpcProviderForStateOverrides(), d = i > 0n ? "0x" + i.toString(16) : void 0, l = await u.send("eth_call", [
+        { from: s, to: r, data: a, value: d },
+        "latest",
+        o
+      ]), [f] = this.routerContract.interface.decodeFunctionResult(c, l);
+      return { amountOut: f, method: c };
+    } else {
+      const u = await this.provider.call({
+        from: s,
+        to: r,
+        data: a,
+        value: i > 0n ? i : void 0
+      }), [d] = this.routerContract.interface.decodeFunctionResult(c, u);
+      return { amountOut: d, method: c };
+    }
+  }
+  getJsonRpcProviderForStateOverrides() {
+    if (typeof this.provider.send != "function")
+      throw new Error(
+        "stateOverrides require a JsonRpcProvider-compatible provider with send(method, params)."
+      );
+    return this.provider;
+  }
+  /**
+   * Format simulate error with human-readable details
+   */
+  formatSimulateError(t, e, n, o) {
+    const s = t instanceof Error ? t : new Error(String(t)), r = t;
+    let a = "unknown";
+    if (r.reason && typeof r.reason == "string")
+      a = r.reason;
+    else if (r.revert && typeof r.revert == "object") {
+      const d = r.revert;
+      d.args && Array.isArray(d.args) && (a = d.args.join(", "));
+    } else s.message && (a = s.message);
+    const i = e.params.steps.map(
+      (d, l) => `  Step ${l}: ${d.tokenIn.slice(0, 10)}→${d.tokenOut.slice(0, 10)} via adapter ${d.adapter.slice(0, 10)} pool ${d.pool.slice(0, 10)}`
+    ).join(`
+`), c = [
+      `Simulate ${n} failed: ${a}`,
+      `  Route: ${e.srcToken} → ${e.dstToken}`,
+      `  AmountIn: ${e.amountIn}`,
+      `  AmountOutMin: ${e.params.amountOutMin}`,
+      `  Router: ${e.routerAddress}`,
+      `  Caller: ${o}`,
+      `  Steps (${e.params.steps.length}):`,
+      i
+    ].join(`
+`), u = new Error(c);
+    return u.cause = s, u.reason = a, u;
+  }
+  /**
+   * Find which step in the route causes the same revert as the full route (e.g. MUL_ERROR).
+   * Simulates with steps [0..1], [0..2], ... and returns the first step whose revert
+   * matches fullRouteError. Ignores steps that revert with a different reason (e.g. unknown custom error).
+   *
+   * @param quote - Full quote from getQuote (the one that fails when simulated)
+   * @param slippageBps - Same as for simulate
+   * @param fromAddress - Same as for simulate
+   * @param stateOverrides - Same as for simulate (use when simulating ERC20 sell with arbitrary address)
+   * @param fullRouteError - The error from simulating the full route. Required so we match by revert reason (e.g. "MUL_ERROR"); only the step that produces the same reason is returned.
+   * @returns The step index and step details whose revert matches fullRouteError, or null if none match or full route succeeds
+   */
+  async findFailingStep(t, e, n, o, s) {
+    const r = t.params.steps;
+    if (!r.length) return null;
+    const a = s != null ? this.normalizeRevertReason(s) : void 0;
+    for (let i = 1; i <= r.length; i++) {
+      const c = this.quoteWithFirstNSteps(t, i);
+      try {
+        await this.simulate(c, e, n, o);
+      } catch (u) {
+        const d = this.normalizeRevertReason(u), l = u?.message ?? u?.reason ?? u?.shortMessage;
+        if (a != null ? d === a : !0)
+          return {
+            stepIndex: i - 1,
+            step: r[i - 1],
+            error: u,
+            revertMessage: typeof l == "string" ? l : void 0,
+            fullRouteRevertMessage: a ?? void 0
+          };
+      }
+    }
+    return null;
+  }
+  /** Extract a comparable revert reason (e.g. "MUL_ERROR") from an error for findFailingStep matching. */
+  normalizeRevertReason(t) {
+    if (t == null) return;
+    const e = t;
+    if (typeof e.reason == "string" && e.reason.length > 0) return e.reason;
+    const n = e.shortMessage ?? e.message;
+    if (typeof n != "string") return;
+    const o = n.match(/reason="([^"]+)"/);
+    if (o) return o[1];
+    const s = n.match(/reverted:\s*"([^"]+)"/);
+    if (s) return s[1];
+    const r = n.match(/execution reverted:\s*"([^"]+)"/);
+    if (r) return r[1];
+  }
+  /** Build a quote that only includes the first stepCount steps (for findFailingStep). */
+  quoteWithFirstNSteps(t, e) {
+    const n = t.params.steps.slice(0, e), o = t.dstToken.toLowerCase(), s = /* @__PURE__ */ new Set(), r = [];
+    for (const a of n) {
+      const i = a.tokenOut.toLowerCase();
+      i !== o && !s.has(i) && (s.add(i), r.push(a.tokenOut));
+    }
+    return {
+      ...t,
+      params: {
+        ...t.params,
+        steps: n,
+        intermediateTokens: r
+      }
+    };
+  }
+  /**
+   * Build state overrides for ERC20 token balance and allowance.
+   * Useful for simulating swaps without actual on-chain token balance/approval.
+   *
+   * Automatically covers multiple storage slot layouts (slots 0-2 for balance,
+   * slots 0-7 for allowance) to handle OZ ERC20 (slot 0/1), Ownable+ERC20 (slot 1/2),
+   * and other common BSC token implementations.
+   *
+   * WBNB (native wrap) is skipped automatically — swapETH wraps msg.value
+   * internally so no ERC20 approval from the sender is needed.
+   *
+   * @param tokenAddress - ERC20 token address (WBNB returns empty overrides)
+   * @param owner - Address that needs the balance and allowance
+   * @param routerAddress - Router address (used as fallback spender)
+   * @param balance - Balance to inject (default: 1M tokens with 18 decimals)
+   * @param spenderAddress - Spender to approve (default: routerAddress). Pass quote.routerAddress when simulating API quotes.
+   */
+  buildStateOverrides(t, e, n, o, s, r) {
+    if (r?.isNative || O(t))
+      return {};
+    if (!n || n === h.ZeroAddress)
+      throw new Error("buildStateOverrides requires a non-zero routerAddress.");
+    const a = h.AbiCoder.defaultAbiCoder(), i = o || h.parseUnits("1000000", 18), c = s ?? n, u = h.zeroPadValue(h.toBeHex(i), 32), d = h.zeroPadValue(h.toBeHex(h.MaxUint256), 32), l = {}, f = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 50, 51, 52, 100, 101, 102];
+    for (const v of f) {
+      const I = h.keccak256(a.encode(["address", "uint256"], [e, v]));
+      l[I] = u;
+      const P = h.keccak256(a.encode(["address", "uint256"], [e, v])), C = h.keccak256(a.encode(["address", "bytes32"], [c, P]));
+      l[C] = d;
+    }
+    return {
+      [t.toLowerCase()]: { stateDiff: l }
+    };
+  }
+}
+const q = [
+  "function token0() external view returns (address)",
+  "function token1() external view returns (address)",
+  "function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)"
+], H = [
+  "function token0() external view returns (address)",
+  "function token1() external view returns (address)",
+  "function fee() external view returns (uint24)",
+  "function liquidity() external view returns (uint128)",
+  "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint32 feeProtocol, bool unlocked)"
+], W = "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73", G = [
+  "function getPair(address tokenA, address tokenB) external view returns (address pair)"
+], K = "0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865", j = [
+  "function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool)"
+], Q = [100, 500, 2500, 1e4], Z = 60000n, z = 120000n, J = 100000n;
+class rt {
+  constructor(t, e) {
+    this.poolCache = /* @__PURE__ */ new Map(), this.provider = t, this.config = e, this.v2Factory = new h.Contract(
+      W,
+      G,
+      t
+    ), this.v3Factory = new h.Contract(
+      K,
+      j,
+      t
+    );
+  }
+  /**
+   * Discover optimal route
+   */
+  async findBestRoute(t, e, n) {
+    const o = await this.discoverPools(t, e);
+    if (o.length === 0)
+      throw new Error(`No pools found for ${t} -> ${e}`);
+    const r = (await this.calculateRoutes(
+      o,
+      t,
+      e,
+      n
+    )).reduce(
+      (a, i) => i.amountOut > a.amountOut ? i : a
+    );
+    return {
+      routes: [r],
+      percentages: [1e4],
+      // 100%
+      totalAmountIn: n,
+      totalAmountOut: r.amountOut,
+      totalGasEstimate: r.gasEstimate
+    };
+  }
+  /**
+   * Discover available pools (direct path)
+   */
+  async discoverPools(t, e) {
+    const n = [];
+    try {
+      const o = await this.findV2Pool(t, e);
+      o && n.push(o);
+    } catch {
+    }
+    for (const o of Q)
+      try {
+        const s = await this.findV3Pool(t, e, o);
+        s && n.push(s);
+      } catch {
+      }
+    return n;
+  }
+  /**
+   * Find V2 pool
+   */
+  async findV2Pool(t, e) {
+    const n = `v2-${t}-${e}`;
+    if (this.poolCache.has(n))
+      return this.poolCache.get(n);
+    const o = await this.v2Factory.getPair(t, e);
+    if (o === h.ZeroAddress)
+      return null;
+    const s = new h.Contract(o, q, this.provider), [r, a, i] = await Promise.all([
+      s.token0(),
+      s.token1(),
+      s.getReserves()
+    ]), c = {
+      address: o,
+      token0: r,
+      token1: a,
+      protocol: g.PancakeV2,
+      reserve0: i.reserve0,
+      reserve1: i.reserve1
+    };
+    return this.poolCache.set(n, c), c;
+  }
+  /**
+   * Find V3 pool
+   */
+  async findV3Pool(t, e, n) {
+    const o = `v3-${t}-${e}-${n}`;
+    if (this.poolCache.has(o))
+      return this.poolCache.get(o);
+    const s = await this.v3Factory.getPool(t, e, n);
+    if (s === h.ZeroAddress)
+      return null;
+    const r = new h.Contract(s, H, this.provider), [a, i, c] = await Promise.all([
+      r.token0(),
+      r.token1(),
+      r.liquidity()
+    ]);
+    if (c === 0n)
+      return null;
+    const u = {
+      address: s,
+      token0: a,
+      token1: i,
+      protocol: g.PancakeV3,
+      fee: n,
+      liquidity: c
+    };
+    return this.poolCache.set(o, u), u;
+  }
+  /**
+   * Calculate route quotes
+   */
+  async calculateRoutes(t, e, n, o) {
+    const s = [];
+    for (const r of t)
+      try {
+        const a = await this.getAmountOut(
+          r,
+          e,
+          n,
+          o
+        );
+        a > 0n && s.push({
+          steps: [
+            {
+              pool: r,
+              tokenIn: e,
+              tokenOut: n,
+              amountIn: o,
+              amountOut: a
+            }
+          ],
+          amountIn: o,
+          amountOut: a,
+          gasEstimate: r.protocol === g.PancakeV2 ? Z : r.protocol === g.Dodo ? J : z
+        });
+      } catch {
+      }
+    return s;
+  }
+  /**
+   * Get output for a single pool
+   */
+  async getAmountOut(t, e, n, o) {
+    if (t.protocol === g.PancakeV2)
+      return this.getV2AmountOut(t, e, o);
+    if (t.protocol === g.Dodo)
+      throw new Error("DODO amount out not supported in local route discovery");
+    return this.estimateV3AmountOut(t, e, o);
+  }
+  /**
+   * V2 output calculation
+   */
+  getV2AmountOut(t, e, n) {
+    const o = e.toLowerCase() === t.token0.toLowerCase(), [s, r] = o ? [t.reserve0, t.reserve1] : [t.reserve1, t.reserve0], a = n * 9975n, i = a * r, c = s * 10000n + a;
+    return i / c;
+  }
+  /**
+   * V3 output estimation (simplified)
+   */
+  estimateV3AmountOut(t, e, n) {
+    const s = 1000000n - BigInt(t.fee || 2500);
+    return n * s / 1000000n;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.poolCache.clear();
+  }
+}
+class st {
+  constructor(t) {
+    this.adapters = t;
+  }
+  /**
+   * Build SwapParams from split route
+   */
+  build(t, e, n, o, s = T) {
+    const r = this.flattenRoutes(t), a = this.mergeIdenticalPools(r), i = this.topologicalSort(a, e), c = this.convertToSwapSteps(i), u = this.extractIntermediates(
+      i,
+      e,
+      n
+    ), d = BigInt(Math.floor(Date.now() / 1e3) + s);
+    return {
+      srcToken: e,
+      dstToken: n,
+      amountIn: t.totalAmountIn,
+      amountOutMin: o,
+      steps: c,
+      intermediateTokens: u,
+      deadline: d,
+      quoteId: h.ZeroHash,
+      expectAmountOut: t.totalAmountOut
+    };
+  }
+  /**
+   * Flatten split route
+   */
+  flattenRoutes(t) {
+    const e = [];
+    for (let n = 0; n < t.routes.length; n++) {
+      const o = t.routes[n], s = t.percentages[n], r = t.totalAmountIn * BigInt(s) / y;
+      for (let a = 0; a < o.steps.length; a++) {
+        const i = o.steps[a];
+        e.push({
+          pool: i.pool,
+          tokenIn: i.tokenIn,
+          tokenOut: i.tokenOut,
+          // Only first step has fixed amount, subsequent steps depend on previous output
+          amountIn: a === 0 ? r : 0n,
+          routeIndex: n,
+          stepIndex: a
+        });
+      }
+    }
+    return e;
+  }
+  /**
+   * Merge identical pools
+   * Key: pool + tokenIn + tokenOut
+   */
+  mergeIdenticalPools(t) {
+    const e = /* @__PURE__ */ new Map(), n = [];
+    for (const o of t) {
+      const s = `${o.pool.address}-${o.tokenIn}-${o.tokenOut}`;
+      if (e.has(s)) {
+        const r = e.get(s);
+        o.amountIn > 0n && r.amountIn > 0n && (r.amountIn = 0n);
+      } else {
+        const r = { ...o };
+        e.set(s, r), n.push(r);
+      }
+    }
+    for (const o of n) {
+      const s = `${o.pool.address}-${o.tokenIn}-${o.tokenOut}`;
+      t.filter(
+        (a) => `${a.pool.address}-${a.tokenIn}-${a.tokenOut}` === s
+      ).length > 1 && (o.amountIn = 0n);
+    }
+    return n;
+  }
+  /**
+   * Topological sort (Kahn's Algorithm)
+   */
+  topologicalSort(t, e) {
+    const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+    for (const i of t) {
+      const c = this.stepKey(i);
+      o.set(c, i), n.set(c, 0), s.set(c, []);
+    }
+    for (const i of t) {
+      const c = this.stepKey(i);
+      if (i.tokenIn !== e) {
+        for (const u of t)
+          if (u.tokenOut === i.tokenIn) {
+            const d = this.stepKey(u);
+            d !== c && (s.get(d).push(c), n.set(c, (n.get(c) || 0) + 1));
+          }
+      }
+    }
+    const r = [];
+    for (const [i, c] of n)
+      c === 0 && r.push(i);
+    const a = [];
+    for (; r.length > 0; ) {
+      const i = r.shift(), c = o.get(i);
+      a.push(c);
+      for (const u of s.get(i) || []) {
+        const d = (n.get(u) || 0) - 1;
+        n.set(u, d), d === 0 && r.push(u);
+      }
+    }
+    if (a.length !== t.length)
+      throw new Error("Circular dependency detected in route");
+    return a;
+  }
+  /**
+   * Convert to contract SwapStep format
+   */
+  convertToSwapSteps(t) {
+    return t.map((e) => {
+      const n = this.adapters.get(e.pool.protocol);
+      if (!n)
+        throw new Error(`No adapter for protocol: ${e.pool.protocol}`);
+      return {
+        adapter: n,
+        pool: e.pool.address,
+        tokenIn: e.tokenIn,
+        tokenOut: e.tokenOut,
+        amountIn: e.amountIn,
+        extraData: this.encodeExtraData(e.pool)
+      };
+    });
+  }
+  /**
+   * Encode protocol-specific parameters
+   */
+  encodeExtraData(t) {
+    switch (t.protocol) {
+      case g.PancakeV2:
+        return "0x";
+      // V2 doesn't need extra parameters
+      case g.PancakeV3:
+      case g.UniswapV3:
+        return "0x";
+      case g.Dodo:
+        return "0x";
+      default:
+        return "0x";
+    }
+  }
+  /**
+   * Extract intermediate tokens
+   */
+  extractIntermediates(t, e, n) {
+    const o = /* @__PURE__ */ new Set();
+    for (const s of t)
+      s.tokenOut !== n && o.add(s.tokenOut);
+    return o.delete(e), o.delete(n), Array.from(o);
+  }
+  /**
+   * Generate unique step key
+   */
+  stepKey(t) {
+    return `${t.pool.address}-${t.tokenIn}-${t.tokenOut}`;
+  }
+}
+export {
+  k as API_DEFAULTS,
+  U as ApiClient,
+  w as ApiError,
+  y as BPS_DENOMINATOR,
+  et as BSC_MAINNET_CONFIG,
+  nt as BSC_TESTNET_CONFIG,
+  T as DEFAULT_DEADLINE_SECONDS,
+  D as DEFAULT_EXECUTE_TIMEOUT_MS,
+  X as DEFAULT_SLIPPAGE_BPS,
+  x as DEFAULT_TRANSACTION_RESPONSE_POLL_INTERVALS_MS,
+  tt as ERR_ZERO_AMOUNT_PATHS,
+  $ as ExecuteTimeoutError,
+  V as NATIVE_TOKEN_ADDRESS,
+  ot as PeachClient,
+  g as ProtocolType,
+  rt as RouteDiscovery,
+  st as SwapBuilder,
+  O as isNativeTokenAddress,
+  b as withWalletSendTimeout
+};
+//# sourceMappingURL=index.mjs.map