@dhedge/trading-widget 6.2.2 → 6.3.2

package/contract-error-log-Ci0TIrO5.js

@@ -0,0 +1,1015 @@
+import { hyperEvm as W, mainnet as I, polygon as st, optimism as at, base as rt, arbitrum as ot } from "wagmi/chains";
+import { aq as it, ao as ct, ap as ut, a as R, q as N, ar as dt, as as pt, a5 as lt, ak as mt, a3 as yt, b as gt, ae as At, Z as k, aj as Et, at as q, e as ht, d as ft, M as St, R as Tt, P as wt, au as _t, av as bt, Q as Dt, N as It, ah as w, _ as Rt, W as Nt, X as Ot, U as Ct, aw as V, ax as xt, ay as Bt, az as Lt, aA as Mt, aB as Pt, ad as Ut } from "./gmx-Cyz_GmV5.js";
+import d from "bignumber.js";
+import { zeroHash as $t, bytesToHex as vt, pad as Ft, stringToHex as O, encodeAbiParameters as T, encodeFunctionData as A, erc20Abi as K, maxUint256 as b } from "viem";
+const x = "application/json";
+class j extends Error {
+  constructor(e, n, s) {
+    super(`HTTP ${e}${s ? `: ${s}` : ""}`), this.name = "FetchRequestError", this.status = e, this.statusText = n, this.body = s;
+  }
+}
+const Ke = (t) => {
+  if (!(t instanceof j) || !t.body)
+    return null;
+  try {
+    return JSON.parse(t.body);
+  } catch {
+    return null;
+  }
+}, Yt = (t) => typeof t == "string" || t instanceof FormData || t instanceof URLSearchParams || t instanceof Blob || t instanceof ArrayBuffer || ArrayBuffer.isView(t), Gt = (t, e) => {
+  const n = String(t), s = e ? new URLSearchParams(e).toString() : "";
+  if (!s)
+    return n;
+  const a = n.indexOf("#"), r = a === -1 ? n : n.slice(0, a), o = a === -1 ? "" : n.slice(a);
+  return `${r}${r.includes("?") ? "&" : "?"}${s}${o}`;
+}, Ht = (t, e) => {
+  const n = new AbortController(), s = () => n.abort();
+  e?.aborted && s();
+  const a = setTimeout(s, t);
+  return e?.addEventListener("abort", s), {
+    signal: n.signal,
+    cleanup: () => {
+      clearTimeout(a), e?.removeEventListener("abort", s);
+    }
+  };
+}, Wt = async (t, e, n) => {
+  if (n === void 0)
+    return await t[e]();
+  const s = Number(t.headers.get("content-length"));
+  if (s > n)
+    throw new Error(`Response too large: ${s} bytes`);
+  if (e === "blob" || e === "arrayBuffer") {
+    const r = await t[e](), o = r instanceof Blob ? r.size : r.byteLength;
+    if (o > n)
+      throw new Error(`Response too large: ${o} bytes`);
+    return r;
+  }
+  const a = await t.text();
+  if (a.length > n)
+    throw new Error(`Response too large: ${a.length} chars`);
+  return e === "json" ? JSON.parse(a) : a;
+}, kt = async ({
+  url: t,
+  headers: e,
+  method: n,
+  body: s,
+  params: a,
+  signal: r,
+  readMethod: o = "json",
+  cache: c,
+  timeoutMs: i,
+  maxResponseBytes: u
+}) => {
+  const l = s !== void 0 && n !== "GET", g = l && !Yt(s), m = new Headers(e);
+  o === "json" && !m.has("Accept") && m.set("Accept", x), g && !m.has("Content-Type") && m.set("Content-Type", x);
+  const f = i ? Ht(i, r) : void 0, nt = {
+    method: n,
+    headers: m,
+    signal: f?.signal ?? r,
+    ...c && { cache: c },
+    ...l && { body: g ? JSON.stringify(s) : s }
+  };
+  try {
+    const E = await fetch(Gt(t, a), nt);
+    if (!E.ok)
+      throw new j(E.status, E.statusText, await E.text().catch(() => ""));
+    return await Wt(E, o, u);
+  } finally {
+    f?.cleanup();
+  }
+}, je = typeof window < "u", Xe = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pool", type: "address" },
+      { internalType: "address", name: "_asset", type: "address" },
+      { internalType: "uint256", name: "_poolTokenAmount", type: "uint256" }
+    ],
+    name: "previewGmTokenAmount",
+    outputs: [
+      { internalType: "uint256", name: "gmTokenAmount", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "ondoGMSwap",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "usdc",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+], qt = [
+  {
+    type: "tuple",
+    components: [
+      { name: "attestationSignature", type: "bytes" },
+      {
+        name: "quote",
+        type: "tuple",
+        components: [
+          { name: "chainId", type: "uint256" },
+          { name: "attestationId", type: "uint256" },
+          { name: "userId", type: "bytes32" },
+          { name: "asset", type: "address" },
+          { name: "price", type: "uint256" },
+          { name: "quantity", type: "uint256" },
+          { name: "expiration", type: "uint256" },
+          { name: "side", type: "uint8" },
+          { name: "additionalData", type: "bytes32" }
+        ]
+      },
+      { name: "amountOutMinimum", type: "uint256" }
+    ]
+  }
+], Vt = [
+  { name: "asset", type: "address" },
+  { name: "amount", type: "uint256" },
+  { name: "assetType", type: "uint16" },
+  { name: "isPool", type: "bool" },
+  { name: "isDebt", type: "bool" },
+  { name: "marketId", type: "uint88" },
+  { name: "accountId", type: "uint256" },
+  { name: "tokenId", type: "uint256" },
+  { name: "debtKey", type: "uint248" },
+  { name: "shares", type: "uint256" }
+], ze = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pool", type: "address" },
+      { internalType: "uint256", name: "_poolTokenAmount", type: "uint256" }
+    ],
+    name: "previewWithdrawal",
+    outputs: [
+      {
+        name: "assetData",
+        type: "tuple[]",
+        components: Vt
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "dytmWithdrawProcessor",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+], C = [
+  {
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "account", type: "uint256" },
+          { name: "tokenId", type: "uint256" },
+          { name: "receiver", type: "address" },
+          { name: "assets", type: "uint256" },
+          { name: "shares", type: "uint256" },
+          { name: "extraData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "withdraw",
+    outputs: [{ name: "assets", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "account", type: "uint256" },
+          { name: "key", type: "uint248" },
+          // DytmParamStructs.TokenType enum — 0 = NONE.
+          { name: "withCollateralType", type: "uint8" },
+          { name: "assets", type: "uint256" },
+          { name: "shares", type: "uint256" },
+          { name: "extraData", type: "bytes" }
+        ]
+      }
+    ],
+    name: "repay",
+    outputs: [{ name: "assetsRepaid", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], Kt = [
+  {
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountOutMinimum", type: "uint256" },
+      { name: "attestationSignature", type: "bytes" },
+      {
+        name: "quote",
+        type: "tuple",
+        components: [
+          { name: "chainId", type: "uint256" },
+          { name: "attestationId", type: "uint256" },
+          { name: "userId", type: "bytes32" },
+          { name: "asset", type: "address" },
+          { name: "price", type: "uint256" },
+          { name: "quantity", type: "uint256" },
+          { name: "expiration", type: "uint256" },
+          { name: "side", type: "uint8" },
+          { name: "additionalData", type: "bytes32" }
+        ]
+      }
+    ],
+    name: "swapExactInWithAttestation",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+], jt = [
+  {
+    type: "tuple",
+    components: [
+      {
+        name: "actions",
+        type: "tuple[]",
+        components: [
+          { name: "to", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "outputAsset", type: "address" },
+      { name: "minOutputAmount", type: "uint256" }
+    ]
+  }
+], D = {
+  stringErrors: {
+    // Ondo tokenized assets trade only during market hours; the full message
+    // includes a dynamic reopen time (e.g. "QUBTon is currently closed for
+    // trading. It will be open in 29 minutes."), so there is no fixed literal
+    // the registry could key on.
+    "currently closed for trading": {
+      title: "The market for this tokenized asset is closed right now",
+      hint: "Wait until the market reopens (the error message says when) and simply retry."
+    },
+    // Synthetix revert hit when a vault still holds deprecated synths.
+    "Synth exchange suspended. Operation prohibited": {
+      title: "Vault includes deprecated synths in portfolio",
+      hint: "Redeem deprecated synth to be able to withdraw."
+    }
+  },
+  selectorErrors: {
+    // EasySwapperV2 swap periphery (see core-kit/abi/easy-swapper-v2.ts).
+    "0x54971d46": {
+      signature: "SwapFailed(address,(address,uint256,(bytes32,bytes)),bytes)",
+      title: "The token swap failed to execute",
+      hint: "Your assets are still in your wallet — try again, or retry with a higher slippage tolerance."
+    },
+    "0x81a815ef": {
+      signature: "InsufficientAmountReceived(address,uint256,uint256)",
+      title: "Swap output was below the minimum received amount",
+      hint: "Increase slippage tolerance and try again."
+    }
+  }
+}, X = (t) => ({
+  stringErrors: {
+    ...t.stringErrors,
+    ...D.stringErrors
+  },
+  selectorErrors: {
+    ...t.selectorErrors,
+    ...D.selectorErrors
+  }
+}), Xt = [
+  "https://cdn.jsdelivr.net/gh/dhedge/V2-Public@master/readmes/errorCodes/registry.json",
+  "https://raw.githubusercontent.com/dhedge/V2-Public/master/readmes/errorCodes/registry.json"
+], zt = 1, Qt = 1e4, Zt = 2e6, Jt = 2e3, te = 500, ee = 120, ne = 300, se = 4, ae = /^dh\d{1,3}$/i, z = /[\u0000-\u001f\u007f]/, re = /https?:\/\/|[<>`]/i, oe = (t) => t.length <= ee && !z.test(t) && (ae.test(t) || t.length >= se), h = (t) => typeof t == "string" && t.length > 0 && t.length <= ne && !z.test(t) && !re.test(t);
+let Q = D, _ = null;
+const Z = () => Q, ie = (t) => {
+  Q = X(t);
+}, ce = (t) => {
+  const e = t;
+  if (e?.schemaVersion !== zt)
+    throw new Error(
+      `Unsupported error registry schemaVersion: ${String(e?.schemaVersion)}`
+    );
+  const n = {};
+  for (const [a, r] of Object.entries(e.stringErrors ?? {}))
+    r?.curated === !0 && oe(a) && h(r.description) && h(r.action) && (n[a] = { title: r.description, hint: r.action });
+  const s = {};
+  for (const [a, r] of Object.entries(e.selectorErrors ?? {}))
+    r?.curated === !0 && /^0x[0-9a-f]{8}$/.test(a) && h(r.signature) && h(r.description) && h(r.action) && (s[a] = {
+      signature: r.signature,
+      title: r.description,
+      hint: r.action
+    });
+  if (!Object.keys(n).length)
+    throw new Error("Error registry contained no curated string errors");
+  if (Object.keys(n).length > Jt || Object.keys(s).length > te)
+    throw new Error("Error registry exceeded expected entry counts");
+  return { stringErrors: n, selectorErrors: s };
+}, ue = async ({
+  timeoutMs: t = Qt
+} = {}) => {
+  const e = [];
+  for (const n of Xt)
+    try {
+      const s = await kt({
+        url: n,
+        method: "GET",
+        timeoutMs: t,
+        maxResponseBytes: Zt
+      });
+      return X(ce(s));
+    } catch (s) {
+      e.push(
+        `${n}: ${s instanceof Error ? s.message : String(s)}`
+      );
+    }
+  throw new Error(`All error registry sources failed: ${e.join("; ")}`);
+}, Qe = () => (_ ?? (_ = ue().then(ie).catch(() => {
+  _ = null;
+})), _), de = () => typeof window < "u";
+function pe() {
+  return de() && typeof window.ethereum < "u";
+}
+async function Ze(t) {
+  try {
+    if (pe())
+      return window.ethereum.request({
+        method: "wallet_watchAsset",
+        params: {
+          type: "ERC20",
+          options: t
+        }
+      });
+  } catch {
+    return !1;
+  }
+  return !1;
+}
+const p = (t, e) => t?.toLowerCase() === e?.toLowerCase(), Je = (t) => p(t, it), S = (t) => {
+  if (!t) throw new Error("Cannot prefix an empty hex value");
+  return t.startsWith("0x") ? t : `0x${t}`;
+}, y = (t, e) => {
+  try {
+    return BigInt(t);
+  } catch {
+    throw new Error(`Cannot convert "${e}" value "${t}" to bigint`);
+  }
+}, B = (t) => t ? Ft(S(t), { size: 32 }) : $t, le = (t) => {
+  if (!t) throw new Error("Cannot decode an empty base64 string");
+  return vt(Uint8Array.from(atob(t), (e) => e.charCodeAt(0)));
+}, me = (t, e) => ut[e]?.[t] ?? R, tn = (t) => ct[t], en = (t) => t && `${t.substring(0, 6)}...${t.substring(
+  t.length - 4,
+  t.length
+)}`, nn = ({
+  address: t,
+  chainId: e
+}) => {
+  const n = me(
+    "aaveLendingPoolV3",
+    e
+  );
+  return p(t, n);
+}, ye = ({
+  sourceAddress: t,
+  amount: e
+}) => `${t}_${e}`, sn = (t, e) => {
+  const n = t.slice(0, e), s = t.slice(e);
+  return { firstPart: n, secondPart: s };
+}, ge = (t, e) => t / e * 100, an = (t) => t < 1 ? 4 : t < 10 ? 3 : 2, rn = (t, e = N) => new d(t.toString()).shiftedBy(e).toFixed(0), on = (t, e, n, s) => new d(e).dividedBy(n).multipliedBy(t).shiftedBy(-(s || N)).toNumber(), cn = (t) => BigInt(
+  new d(t || "0").shiftedBy(N).toFixed(0, d.ROUND_DOWN)
+), J = (t) => {
+  const e = new d(0.01), n = new d(t), s = !n.isZero() && n.lt(e) ? e : n;
+  return BigInt(s.multipliedBy(100).toFixed(0));
+}, un = ({
+  chainId: t,
+  slippage: e
+}) => t === W.id ? BigInt(0) : J(e), dn = ({
+  vaultAddress: t,
+  swapData: e,
+  sendTokenAddress: n,
+  sendTokenAmount: s,
+  vaultDepositTokenAddress: a,
+  minVaultTokensReceivedAmount: r,
+  routerKey: o = "ONE_INCH",
+  swapDestinationAmount: c,
+  swapSlippage: i
+}) => {
+  const u = new d(c).multipliedBy(1 - i / 100).toFixed(0), l = [O(o, { size: 32 }), e];
+  return [t, [[n, s, l], [a, u]], r];
+}, pn = ({
+  receiveAssetAddress: t,
+  assets: e,
+  swapData: n,
+  slippage: s
+}) => {
+  const a = {
+    srcData: [],
+    destAmount: new d("0")
+  }, { srcData: r, destAmount: o } = e?.reduce((c, i) => {
+    const u = n?.[i.address];
+    if (!u)
+      return c;
+    const l = [
+      O(u.routerKey, { size: 32 }),
+      u.rawTransaction.data
+    ], g = [i.address, i.rawBalance, l];
+    return {
+      srcData: [...c.srcData, g],
+      destAmount: c.destAmount.plus(u.destinationAmount)
+    };
+  }, a) ?? a;
+  return [
+    r,
+    [
+      t,
+      o.times(1 - s / 100).toFixed(0, d.ROUND_DOWN)
+    ]
+  ];
+}, Ae = ({
+  assetAddress: t,
+  swapQuotes: e,
+  swapParams: n,
+  slippageToleranceForContractTransaction: s,
+  routerKey: a
+}) => {
+  if (!n)
+    return {
+      supportedAsset: t,
+      withdrawData: "",
+      slippageTolerance: BigInt(0)
+    };
+  const { srcData: r, dstData: o } = n, c = r.map(({ asset: l, amount: g }) => {
+    const m = e?.[ye({
+      sourceAddress: l,
+      amount: g.toString()
+    })]?.find((f) => f.routerKey === a);
+    return {
+      asset: l,
+      amount: g,
+      swapData: {
+        routerKey: O(m?.routerKey ?? "", { size: 32 }),
+        txData: m?.rawTransaction.data ?? "0x"
+      }
+    };
+  }), i = T(
+    dt,
+    [c]
+  ), u = T(pt, [
+    {
+      encodedSrcData: i,
+      dstData: {
+        dstAddress: o.asset,
+        dstAmount: o.amount
+      },
+      slippage: s
+    }
+  ]);
+  return {
+    supportedAsset: t,
+    withdrawData: u,
+    slippageTolerance: s
+  };
+}, ln = ({
+  chainId: t,
+  txHash: e,
+  error: n
+}) => {
+  if (t !== I.id || !e || !n)
+    return !1;
+  const s = n instanceof Error ? n.message : String(n);
+  return /\bNo Result\b/i.test(s);
+}, mn = ({
+  chainId: t,
+  action: e,
+  isRabbyWallet: n
+}) => e === "update_ondo_prices" && t === I.id && n ? lt : t ? mt[t] ?? 0 : 0, yn = (t, e) => gt[e]?.nativeTokenSymbol === t, gn = ({
+  nativeTokenBalance: t,
+  tokenDecimals: e,
+  gasPrice: n
+}) => {
+  const s = new d(n).multipliedBy(yt).shiftedBy(-e), a = new d(t).minus(
+    s
+  );
+  return a.gt("0") ? a : new d("0");
+}, An = (t) => At.includes(t), En = (t) => {
+  const e = Object.values(t).reduce(
+    (n, { type: s }) => (n[s] = n[s] + 1, n),
+    { string: 0, number: 0 }
+  );
+  if (e.string > 10)
+    throw new Error("logger params must contain up to 10 string values");
+  if (e.number > 40)
+    throw new Error("logger params must contain up to 40 numeric values");
+  return !0;
+}, Ee = (t, e = 150) => t.length > e ? t.substring(0, e) : t, tt = () => ({
+  ...Z().stringErrors,
+  ...Et
+}), he = () => [
+  ...Object.keys(tt()),
+  ...Object.keys(k)
+], fe = /^dh\d+$/i, Se = (t, e) => fe.test(e) ? new RegExp(`\\b${e}\\b`, "i").test(t) : t.includes(e.toLowerCase()), L = (t, e) => {
+  const n = t.toLowerCase();
+  return [...e ?? he()].sort((s, a) => a.length - s.length).find((s) => Se(n, s));
+}, M = (t) => tt()[t] ?? k[t], Te = /\b0x[0-9a-f]{8}\b/i, we = (t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), _e = (t) => {
+  const { selectorErrors: e } = Z(), n = t.match(Te)?.[0]?.toLowerCase(), s = n ? e[n] : void 0;
+  if (s)
+    return { title: s.title, hint: s.hint };
+  const a = Object.values(e).find(
+    (r) => new RegExp(
+      `\\b${we(r.signature.split("(")[0] ?? "")}\\b`
+    ).test(t)
+  );
+  return a ? { title: a.title, hint: a.hint } : void 0;
+}, hn = ({
+  errorMessage: t,
+  abiErrors: e
+}) => {
+  if (!t || t.includes("User rejected"))
+    return null;
+  const n = e.find((o) => t.includes(o));
+  if (n) {
+    const o = L(n);
+    if (o)
+      return M(o);
+  }
+  const s = L(t);
+  if (s)
+    return M(s);
+  const a = _e(t);
+  if (a)
+    return a;
+  const [r] = t.split(n ? "." : "Contract").map((o) => o.trim());
+  return {
+    title: "Transaction failed",
+    hint: `${Ee(r ?? "")} ${n ? `: ${n}` : ""}`
+  };
+}, fn = (t) => typeof t == "number" && Number.isFinite(t), Sn = (t) => typeof t == "bigint" && t !== BigInt(0), be = (t, e = q) => new d(t).shiftedBy(-e).toNumber(), De = (t) => !isNaN(parseFloat(t)) && !isNaN(t), Ie = ({
+  value: t,
+  minimumFractionDigits: e = 2,
+  maximumFractionDigits: n = 2,
+  compact: s = !1,
+  normalize: a = !1
+}) => new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  notation: s ? "compact" : void 0,
+  minimumFractionDigits: e,
+  maximumFractionDigits: n
+}).format(a ? be(t) : Number(t)), P = (t) => De(t) ? new d(t).toFixed() : "", U = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"], Re = ({
+  value: t,
+  decimals: e = 4
+}) => {
+  const n = new d(t);
+  if (n.isGreaterThan(1) || n.isZero())
+    return P(n.toFixed(e));
+  const a = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed(q) : t.toString()).match(/^0\.(0+)(\d+)$/);
+  if (a) {
+    const [, r, o] = a;
+    if (r.length >= e && r.length < U.length)
+      return `0.0${U[r.length]}${o.slice(0, 3)}`;
+  }
+  return P(n.toFixed(e));
+}, Ne = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`, Tn = (t) => t.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), wn = (t, e, n = 0) => {
+  const s = ge(+t, e);
+  return Ne(s, n);
+}, _n = ({
+  currency: t,
+  value: e
+}) => t === "USD" ? Ie({ value: e }) : `${ht[t]} ${Re({
+  value: e,
+  decimals: ft[t]
+})}`, Oe = (t, e) => new d(
+  new d(t).toFixed(e, d.ROUND_DOWN)
+).toString(), Ce = (t, e = 3, n = 2) => {
+  if (t.length <= 5)
+    return t;
+  const s = "...";
+  return t.length <= e + n + s.length ? t : `${t.slice(0, e)}${s}${t.slice(-n)}`;
+}, bn = ({
+  balance: t,
+  symbol: e,
+  precision: n,
+  truncateSymbol: s
+}) => `${Oe(t, n)} ${s ? Ce(e) : e}`, Dn = (t) => {
+  if (!t)
+    return;
+  const e = t.match(/0x[a-fA-F0-9]{64}/);
+  if (!e)
+    return;
+  const n = e[0];
+  return `${n.slice(0, 4)}...${n.slice(-3)}`;
+}, In = (t) => p(_t, t) || p(bt, t), Rn = (t) => It.some(
+  (e) => p(e, t)
+), Nn = (t) => St[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: R
+}, On = (t) => p(t, Dt) ? Tt : wt, xe = (t) => `eth_${t}`, Cn = ({
+  action: t,
+  log: e,
+  symbol: n,
+  vaultAddress: s,
+  chainId: a
+}) => {
+  const r = {
+    [w.SYMBOL.NAME]: n,
+    [w.CHAIN_ID.NAME]: a,
+    [w.ADDRESS.NAME]: xe(s)
+  };
+  Rt[t].forEach((o) => {
+    e?.(o, r);
+  });
+}, xn = (t) => Ct.some((e) => p(e, t)), Bn = (t) => Nt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: R
+}, Ln = (t) => Ot[t.toLowerCase()], Be = "0x3333333333333333333333333333333333333333";
+ot.id + "", Pt.address, rt.id + "", Mt.address, at.id + "", Lt.address, st.id + "", Bt.address, I.id + "", xt.address, W.id + "", V.address;
+const Le = "0x2222222222222222222222222222222222222222", $ = BigInt("0x2000000000000000000000000000000000000000"), Me = 10000n, Pe = (t) => p(t, Be), Ue = (t) => {
+  if (p(t, Le))
+    return !0;
+  try {
+    const e = BigInt(t);
+    return e >= $ && e < $ + Me;
+  } catch {
+    return !1;
+  }
+}, Mn = (t) => Pe(t) || Ue(t), Pn = () => V, Un = /* @__PURE__ */ new Map(), et = (t, e) => !e || e.size === 0 ? t : t.map((n) => {
+  const s = e.get(
+    n.supportedAsset.toLowerCase()
+  );
+  return s ? {
+    ...n,
+    withdrawData: s.withdrawData,
+    slippageTolerance: s.slippageTolerance
+  } : n;
+}), $e = (t) => {
+  const e = t.find(
+    ({ swapQuotes: n }) => n
+  );
+  return e?.swapQuotes ? Object.values(e.swapQuotes)[0]?.map(
+    ({ routerKey: n }) => n
+  ) ?? [] : [];
+}, ve = (t, e, n) => t.map(({ asset: s, swapParams: a, swapQuotes: r }) => !a || !r ? {
+  supportedAsset: s,
+  withdrawData: "",
+  slippageTolerance: n
+} : Ae({
+  assetAddress: s,
+  swapQuotes: r,
+  swapParams: a,
+  slippageToleranceForContractTransaction: n,
+  routerKey: e
+})), Fe = async (t, e, n, s, a, r) => {
+  for (const o of t) {
+    const c = et(
+      ve(
+        e,
+        o,
+        n
+      ),
+      r
+    ), { error: i } = await s(...a, c);
+    if (!i)
+      return c;
+  }
+  return null;
+}, $n = (t, e, n) => {
+  const s = (t ?? []).map((a) => ({
+    supportedAsset: a,
+    withdrawData: "",
+    slippageTolerance: e
+  }));
+  return et(s, n);
+}, vn = async (t, e, n, s, a) => {
+  for (const r of t) {
+    const o = J(r);
+    try {
+      const c = await e(r), i = $e(
+        c
+      ), u = await Fe(
+        i,
+        c,
+        o,
+        n,
+        s,
+        a
+      );
+      if (u)
+        return console.debug(
+          `[Init Withdraw] Auto slippage simulation succeeded: slippage=${r}%`
+        ), console.debug("[Init Withdraw] Complex asset data:", u), u;
+    } catch (c) {
+      console.error(
+        `[Init Withdraw] Failed to fetch quotes for slippage=${r}%:`,
+        c
+      );
+    }
+  }
+  return null;
+}, Fn = async (t, e, {
+  fetchAaveSwapParams: n,
+  fetchAaveSwapQuotes: s,
+  withdrawAmountD18: a,
+  slippage: r
+}) => Promise.all(
+  (t ?? []).map(async (o) => {
+    if (!p(o, e))
+      return { asset: o };
+    try {
+      const i = await n({
+        withdrawAmountD18: a,
+        slippage: r
+      });
+      if (i?.srcData.length) {
+        const u = await s({
+          swapParams: i,
+          slippage: r
+        });
+        return { asset: o, swapParams: i, swapQuotes: u };
+      }
+      return { asset: o };
+    } catch (i) {
+      return console.error(i), { asset: o };
+    }
+  })
+), v = (t) => Math.round(t * 100) / 100, Yn = ({
+  maxSlippage: t,
+  candidates: e = Ut
+}) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return [];
+  const n = v(Math.min(t, 100)), s = e.filter((r) => r > 0 && r <= n).map(v), a = new Set(s);
+  return a.add(n), a.add(t), Array.from(a).sort((r, o) => r - o);
+}, F = 1000000000000000000n, Ye = 1000000n, Y = 10000n, G = 100n, Gn = (t) => ({
+  quotes: t.quotes.map(
+    (e) => ({
+      chainId: y(e.chainId, "chainId"),
+      attestationId: y(e.attestationId, "attestationId"),
+      userId: S(e.userId),
+      asset: e.asset,
+      price: y(e.price, "price"),
+      quantity: y(e.quantity, "quantity"),
+      expiration: y(e.expiration, "expiration"),
+      side: Number(e.side),
+      additionalData: S(e.additionalData)
+    })
+  ),
+  signatures: t.signatures.map(S)
+}), Ge = (t, e, n) => {
+  const s = BigInt(Math.max(0, Math.round(n * 100))), a = s > G ? G : s, r = Y - a, c = t * e / F * r * Ye, i = Y * F;
+  return (c + i - 1n) / i;
+}, He = (t, e) => ({
+  chainId: e,
+  attestationId: y(t.attestationId, "attestationId"),
+  userId: B(t.userId),
+  asset: t.assetAddress,
+  price: y(t.price, "price"),
+  quantity: y(t.tokenAmount, "tokenAmount"),
+  expiration: y(t.expiration, "expiration"),
+  side: Number(t.side),
+  additionalData: B(t.additionalData)
+}), Hn = ({
+  attestation: t,
+  chainId: e,
+  slippagePercent: n
+}) => {
+  const s = He(t, e);
+  return T(qt, [
+    {
+      attestationSignature: le(t.signature),
+      quote: s,
+      amountOutMinimum: Ge(
+        s.quantity,
+        s.price,
+        n
+      )
+    }
+  ]);
+}, Wn = (t) => [...t.reduce(
+  (n, s) => n.has(s.accountId) ? n : n.set(s.accountId, s),
+  /* @__PURE__ */ new Map()
+).values()].map(({ accountId: n, marketId: s }) => ({
+  accountId: n,
+  marketId: s,
+  collaterals: t.filter(
+    (a) => a.accountId === n && !a.isDebt
+  ),
+  debt: t.find(
+    (a) => a.accountId === n && a.isDebt
+  )
+})), kn = ({
+  collateral: t,
+  dytmOffice: e,
+  processor: n,
+  gmToken: s,
+  ondoGMSwap: a,
+  usdc: r,
+  gmAmount: o,
+  amountOutMinimum: c,
+  signature: i,
+  quote: u
+}) => [
+  {
+    // 1 · pull GM collateral out of the split account -> processor
+    to: e,
+    data: A({
+      abi: C,
+      functionName: "withdraw",
+      args: [
+        {
+          account: t.accountId,
+          tokenId: t.tokenId,
+          receiver: n,
+          assets: o,
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  },
+  {
+    // 2 · approve the GM token to Ondo's swap contract
+    to: s,
+    data: A({
+      abi: K,
+      functionName: "approve",
+      args: [a, o]
+    })
+  },
+  {
+    // 3 · redeem GM -> USDC with the signed attestation
+    to: a,
+    data: A({
+      abi: Kt,
+      functionName: "swapExactInWithAttestation",
+      args: [s, o, r, c, i, u]
+    })
+  }
+], qn = ({
+  collateral: t,
+  dytmOffice: e,
+  processor: n
+}) => ({
+  to: e,
+  data: A({
+    abi: C,
+    functionName: "withdraw",
+    args: [
+      {
+        account: t.accountId,
+        tokenId: t.tokenId,
+        receiver: n,
+        assets: 0n,
+        shares: b,
+        extraData: "0x"
+      }
+    ]
+  })
+}), Vn = ({
+  accountId: t,
+  debtKey: e,
+  dytmOffice: n,
+  usdc: s
+}) => [
+  {
+    // approve USDC to the DYTM Office for the repay
+    to: s,
+    data: A({
+      abi: K,
+      functionName: "approve",
+      args: [n, b]
+    })
+  },
+  {
+    // repay the slice's whole USDC debt
+    to: n,
+    data: A({
+      abi: C,
+      functionName: "repay",
+      args: [
+        {
+          account: t,
+          key: e,
+          withCollateralType: 0,
+          // DytmParamStructs.TokenType.NONE
+          assets: b,
+          // repay all
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  }
+], Kn = ({
+  actions: t,
+  outputAsset: e,
+  minOutputAmount: n
+}) => T(jt, [
+  { actions: t, outputAsset: e, minOutputAmount: n }
+]), H = /* @__PURE__ */ new Set(), jn = (t) => {
+  const e = t?.message;
+  !e || H.has(e) || (H.add(e), console.warn(e));
+};
+export {
+  An as $,
+  tn as A,
+  me as B,
+  Z as C,
+  an as D,
+  Un as E,
+  L as F,
+  Nn as G,
+  On as H,
+  Bn as I,
+  Ln as J,
+  Pn as K,
+  gn as L,
+  ge as M,
+  on as N,
+  mn as O,
+  J as P,
+  Dn as Q,
+  Wn as R,
+  nn as S,
+  D as T,
+  Rn as U,
+  In as V,
+  xn as W,
+  Mn as X,
+  Pe as Y,
+  Ue as Z,
+  yn as _,
+  ie as a,
+  jn as a0,
+  Cn as a1,
+  He as a2,
+  Gn as a3,
+  et as a4,
+  cn as a5,
+  hn as a6,
+  rn as a7,
+  en as a8,
+  ln as a9,
+  sn as aa,
+  y as ab,
+  B as ac,
+  xe as ad,
+  Ce as ae,
+  Fe as af,
+  vn as ag,
+  En as ah,
+  kt as ai,
+  Ke as aj,
+  Je as ak,
+  fn as al,
+  p as am,
+  Ie as an,
+  Sn as ao,
+  be as ap,
+  ze as aq,
+  Xe as ar,
+  Be as as,
+  Re as at,
+  Ze as au,
+  Ne as av,
+  De as aw,
+  Tn as ax,
+  P as ay,
+  le as b,
+  Ae as c,
+  ve as d,
+  kn as e,
+  qn as f,
+  Vn as g,
+  ye as h,
+  pn as i,
+  dn as j,
+  je as k,
+  Ge as l,
+  $n as m,
+  Hn as n,
+  Kn as o,
+  Fn as p,
+  Qe as q,
+  S as r,
+  $e as s,
+  ue as t,
+  Oe as u,
+  _n as v,
+  wn as w,
+  bn as x,
+  Yn as y,
+  un as z
+};