@dhedge/trading-widget 6.1.1 → 6.2.0-canary.1

package/dytm-DycL7_hQ.js

@@ -0,0 +1,864 @@
+import { mainnet as S, hyperEvm as j, polygon as X, optimism as z, base as Q, arbitrum as Z } from "wagmi/chains";
+import { aq as J, ao as tt, ap as et, a as w, q as D, ar as nt, as as st, a5 as at, ak as rt, a3 as ot, b as it, ae as ct, Z as F, aj as ut, at as $, e as dt, d as pt, M as mt, R as lt, P as yt, au as At, av as Et, Q as gt, N as ht, ah as _, _ as ft, W as _t, X as Tt, U as St, aw as v, ax as wt, ay as Dt, az as bt, aA as It, aB as Nt, ad as Rt } from "./gmx-Cyz_GmV5.js";
+import u from "bignumber.js";
+import { zeroHash as Ot, bytesToHex as Ct, pad as Mt, stringToHex as b, encodeAbiParameters as h, encodeFunctionData as E, erc20Abi as G, maxUint256 as I } from "viem";
+const Ce = typeof window < "u", Me = [
+  {
+    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"
+  }
+], Lt = [
+  {
+    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" }
+    ]
+  }
+], Bt = [
+  { 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" }
+], Le = [
+  {
+    inputs: [
+      { internalType: "address", name: "_pool", type: "address" },
+      { internalType: "uint256", name: "_poolTokenAmount", type: "uint256" }
+    ],
+    name: "previewWithdrawal",
+    outputs: [
+      {
+        name: "assetData",
+        type: "tuple[]",
+        components: Bt
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "dytmWithdrawProcessor",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+], Y = [
+  {
+    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"
+  }
+], xt = [
+  {
+    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"
+  }
+], Pt = [
+  {
+    type: "tuple",
+    components: [
+      {
+        name: "actions",
+        type: "tuple[]",
+        components: [
+          { name: "to", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "outputAsset", type: "address" },
+      { name: "minOutputAmount", type: "uint256" }
+    ]
+  }
+], Ut = [
+  "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"
+], Ft = 1, $t = 1e4, N = 2e6, vt = 2e3, Gt = 500, Yt = 120, Wt = 300, Ht = 4, Kt = /^dh\d{1,3}$/i, W = /[\u0000-\u001f\u007f]/, Vt = /https?:\/\/|[<>`]/i, kt = (t) => t.length <= Yt && !W.test(t) && (Kt.test(t) || t.length >= Ht), A = (t) => typeof t == "string" && t.length > 0 && t.length <= Wt && !W.test(t) && !Vt.test(t), qt = {
+  stringErrors: {},
+  selectorErrors: {}
+};
+let H = qt, T = null;
+const K = () => H, jt = (t) => {
+  H = t;
+}, Xt = (t) => {
+  const e = t;
+  if (e?.schemaVersion !== Ft)
+    throw new Error(
+      `Unsupported error registry schemaVersion: ${String(e?.schemaVersion)}`
+    );
+  const n = {};
+  for (const [r, a] of Object.entries(e.stringErrors ?? {}))
+    a?.curated === !0 && kt(r) && A(a.description) && A(a.action) && (n[r] = { title: a.description, hint: a.action });
+  const s = {};
+  for (const [r, a] of Object.entries(e.selectorErrors ?? {}))
+    a?.curated === !0 && /^0x[0-9a-f]{8}$/.test(r) && A(a.signature) && A(a.description) && A(a.action) && (s[r] = {
+      signature: a.signature,
+      title: a.description,
+      hint: a.action
+    });
+  if (!Object.keys(n).length)
+    throw new Error("Error registry contained no curated string errors");
+  if (Object.keys(n).length > vt || Object.keys(s).length > Gt)
+    throw new Error("Error registry exceeded expected entry counts");
+  return { stringErrors: n, selectorErrors: s };
+}, zt = async ({
+  timeoutMs: t = $t
+} = {}) => {
+  const e = [];
+  for (const n of Ut) {
+    const s = new AbortController(), r = setTimeout(() => s.abort(), t);
+    try {
+      const a = await fetch(n, {
+        headers: { accept: "application/json" },
+        signal: s.signal
+      });
+      if (!a.ok) throw new Error(`HTTP ${a.status}`);
+      const o = Number(a.headers.get("content-length"));
+      if (o > N)
+        throw new Error(`Response too large: ${o} bytes`);
+      const i = await a.text();
+      if (i.length > N)
+        throw new Error(`Response too large: ${i.length} chars`);
+      return Xt(JSON.parse(i));
+    } catch (a) {
+      e.push(
+        `${n}: ${a instanceof Error ? a.message : String(a)}`
+      );
+    } finally {
+      clearTimeout(r);
+    }
+  }
+  throw new Error(`All error registry sources failed: ${e.join("; ")}`);
+}, Be = () => (T ?? (T = zt().then(jt).catch(() => {
+  T = null;
+})), T), Qt = () => typeof window < "u";
+function Zt() {
+  return Qt() && typeof window.ethereum < "u";
+}
+async function xe(t) {
+  try {
+    if (Zt())
+      return window.ethereum.request({
+        method: "wallet_watchAsset",
+        params: {
+          type: "ERC20",
+          options: t
+        }
+      });
+  } catch {
+    return !1;
+  }
+  return !1;
+}
+const m = (t, e) => t?.toLowerCase() === e?.toLowerCase(), Pe = (t) => m(t, J), g = (t) => {
+  if (!t) throw new Error("Cannot prefix an empty hex value");
+  return t.startsWith("0x") ? t : `0x${t}`;
+}, p = (t, e) => {
+  try {
+    return BigInt(t);
+  } catch {
+    throw new Error(`Cannot convert "${e}" value "${t}" to bigint`);
+  }
+}, R = (t) => t ? Mt(g(t), { size: 32 }) : Ot, Jt = (t) => {
+  if (!t) throw new Error("Cannot decode an empty base64 string");
+  return Ct(Uint8Array.from(atob(t), (e) => e.charCodeAt(0)));
+}, te = (t, e) => et[e]?.[t] ?? w, Ue = (t) => tt[t], Fe = (t) => t && `${t.substring(0, 6)}...${t.substring(
+  t.length - 4,
+  t.length
+)}`, $e = ({
+  address: t,
+  chainId: e
+}) => {
+  const n = te(
+    "aaveLendingPoolV3",
+    e
+  );
+  return m(t, n);
+}, ee = ({
+  sourceAddress: t,
+  amount: e
+}) => `${t}_${e}`, ve = (t, e) => {
+  const n = t.slice(0, e), s = t.slice(e);
+  return { firstPart: n, secondPart: s };
+}, ne = (t, e) => t / e * 100, Ge = (t) => t < 1 ? 4 : t < 10 ? 3 : 2, Ye = (t, e = D) => new u(t.toString()).shiftedBy(e).toFixed(0), We = (t, e, n, s) => new u(e).dividedBy(n).multipliedBy(t).shiftedBy(-(s || D)).toNumber(), He = (t) => BigInt(
+  new u(t || "0").shiftedBy(D).toFixed(0, u.ROUND_DOWN)
+), se = (t) => {
+  const e = new u(0.01), n = new u(t), s = !n.isZero() && n.lt(e) ? e : n;
+  return BigInt(s.multipliedBy(100).toFixed(0));
+}, Ke = ({
+  vaultAddress: t,
+  swapData: e,
+  sendTokenAddress: n,
+  sendTokenAmount: s,
+  vaultDepositTokenAddress: r,
+  minVaultTokensReceivedAmount: a,
+  routerKey: o = "ONE_INCH",
+  swapDestinationAmount: i,
+  swapSlippage: c
+}) => {
+  const d = new u(i).multipliedBy(1 - c / 100).toFixed(0), l = [b(o, { size: 32 }), e];
+  return [t, [[n, s, l], [r, d]], a];
+}, Ve = ({
+  receiveAssetAddress: t,
+  assets: e,
+  swapData: n,
+  slippage: s
+}) => {
+  const r = {
+    srcData: [],
+    destAmount: new u("0")
+  }, { srcData: a, destAmount: o } = e?.reduce((i, c) => {
+    const d = n?.[c.address];
+    if (!d)
+      return i;
+    const l = [
+      b(d.routerKey, { size: 32 }),
+      d.rawTransaction.data
+    ], y = [c.address, c.rawBalance, l];
+    return {
+      srcData: [...i.srcData, y],
+      destAmount: i.destAmount.plus(d.destinationAmount)
+    };
+  }, r) ?? r;
+  return [
+    a,
+    [
+      t,
+      o.times(1 - s / 100).toFixed(0, u.ROUND_DOWN)
+    ]
+  ];
+}, ae = ({
+  assetAddress: t,
+  swapQuotes: e,
+  swapParams: n,
+  slippageToleranceForContractTransaction: s,
+  routerKey: r
+}) => {
+  if (!n)
+    return {
+      supportedAsset: t,
+      withdrawData: "",
+      slippageTolerance: BigInt(0)
+    };
+  const { srcData: a, dstData: o } = n, i = a.map(({ asset: l, amount: y }) => {
+    const f = e?.[ee({
+      sourceAddress: l,
+      amount: y.toString()
+    })]?.find((q) => q.routerKey === r);
+    return {
+      asset: l,
+      amount: y,
+      swapData: {
+        routerKey: b(f?.routerKey ?? "", { size: 32 }),
+        txData: f?.rawTransaction.data ?? "0x"
+      }
+    };
+  }), c = h(
+    nt,
+    [i]
+  ), d = h(st, [
+    {
+      encodedSrcData: c,
+      dstData: {
+        dstAddress: o.asset,
+        dstAmount: o.amount
+      },
+      slippage: s
+    }
+  ]);
+  return {
+    supportedAsset: t,
+    withdrawData: d,
+    slippageTolerance: s
+  };
+}, ke = ({
+  chainId: t,
+  txHash: e,
+  error: n
+}) => {
+  if (t !== S.id || !e || !n)
+    return !1;
+  const s = n instanceof Error ? n.message : String(n);
+  return /\bNo Result\b/i.test(s);
+}, qe = ({
+  chainId: t,
+  action: e,
+  isRabbyWallet: n
+}) => e === "update_ondo_prices" && t === S.id && n ? at : t ? rt[t] ?? 0 : 0, je = (t, e) => it[e]?.nativeTokenSymbol === t, Xe = ({
+  nativeTokenBalance: t,
+  tokenDecimals: e,
+  gasPrice: n
+}) => {
+  const s = new u(n).multipliedBy(ot).shiftedBy(-e), r = new u(t).minus(
+    s
+  );
+  return r.gt("0") ? r : new u("0");
+}, ze = (t) => ct.includes(t), Qe = (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;
+}, re = (t, e = 150) => t.length > e ? t.substring(0, e) : t, V = () => ({
+  ...K().stringErrors,
+  ...ut
+}), oe = () => [
+  ...Object.keys(V()),
+  ...Object.keys(F)
+], ie = /^dh\d+$/i, ce = (t, e) => ie.test(e) ? new RegExp(`\\b${e}\\b`, "i").test(t) : t.includes(e.toLowerCase()), O = (t, e) => {
+  const n = t.toLowerCase();
+  return [...e ?? oe()].sort((s, r) => r.length - s.length).find((s) => ce(n, s));
+}, C = (t) => V()[t] ?? F[t], ue = /\b0x[0-9a-f]{8}\b/i, de = (t) => {
+  const e = t.match(ue)?.[0]?.toLowerCase(), n = e ? K().selectorErrors[e] : void 0;
+  return n ? { title: n.title, hint: n.hint } : void 0;
+}, Ze = ({
+  errorMessage: t,
+  abiErrors: e
+}) => {
+  if (!t || t.includes("User rejected"))
+    return null;
+  const n = e.find((o) => t.includes(o));
+  if (n) {
+    const o = O(n);
+    if (o)
+      return C(o);
+  }
+  const s = O(t);
+  if (s)
+    return C(s);
+  const r = de(t);
+  if (r)
+    return r;
+  const [a] = t.split(n ? "." : "Contract").map((o) => o.trim());
+  return {
+    title: "Transaction failed",
+    hint: `${re(a ?? "")} ${n ? `: ${n}` : ""}`
+  };
+}, Je = (t) => typeof t == "number" && Number.isFinite(t), tn = (t) => typeof t == "bigint" && t !== BigInt(0), pe = (t, e = $) => new u(t).shiftedBy(-e).toNumber(), me = (t) => !isNaN(parseFloat(t)) && !isNaN(t), le = ({
+  value: t,
+  minimumFractionDigits: e = 2,
+  maximumFractionDigits: n = 2,
+  compact: s = !1,
+  normalize: r = !1
+}) => new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  notation: s ? "compact" : void 0,
+  minimumFractionDigits: e,
+  maximumFractionDigits: n
+}).format(r ? pe(t) : Number(t)), M = (t) => me(t) ? new u(t).toFixed() : "", L = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"], ye = ({
+  value: t,
+  decimals: e = 4
+}) => {
+  const n = new u(t);
+  if (n.isGreaterThan(1) || n.isZero())
+    return M(n.toFixed(e));
+  const r = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed($) : t.toString()).match(/^0\.(0+)(\d+)$/);
+  if (r) {
+    const [, a, o] = r;
+    if (a.length >= e && a.length < L.length)
+      return `0.0${L[a.length]}${o.slice(0, 3)}`;
+  }
+  return M(n.toFixed(e));
+}, Ae = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`, en = (t) => t.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), nn = (t, e, n = 0) => {
+  const s = ne(+t, e);
+  return Ae(s, n);
+}, sn = ({
+  currency: t,
+  value: e
+}) => t === "USD" ? le({ value: e }) : `${dt[t]} ${ye({
+  value: e,
+  decimals: pt[t]
+})}`, Ee = (t, e) => new u(
+  new u(t).toFixed(e, u.ROUND_DOWN)
+).toString(), ge = (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)}`;
+}, an = ({
+  balance: t,
+  symbol: e,
+  precision: n,
+  truncateSymbol: s
+}) => `${Ee(t, n)} ${s ? ge(e) : e}`, rn = (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)}`;
+}, on = (t) => m(At, t) || m(Et, t), cn = (t) => ht.some(
+  (e) => m(e, t)
+), un = (t) => mt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: w
+}, dn = (t) => m(t, gt) ? lt : yt, he = (t) => `eth_${t}`, pn = ({
+  action: t,
+  log: e,
+  symbol: n,
+  vaultAddress: s,
+  chainId: r
+}) => {
+  const a = {
+    [_.SYMBOL.NAME]: n,
+    [_.CHAIN_ID.NAME]: r,
+    [_.ADDRESS.NAME]: he(s)
+  };
+  ft[t].forEach((o) => {
+    e?.(o, a);
+  });
+}, mn = (t) => St.some((e) => m(e, t)), ln = (t) => _t[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: w
+}, yn = (t) => Tt[t.toLowerCase()], fe = "0x3333333333333333333333333333333333333333";
+Z.id + "", Nt.address, Q.id + "", It.address, z.id + "", bt.address, X.id + "", Dt.address, S.id + "", wt.address, j.id + "", v.address;
+const An = (t) => m(t, fe), En = () => v, gn = /* @__PURE__ */ new Map(), k = (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
+  ) ?? [] : [];
+}, Te = (t, e, n) => t.map(({ asset: s, swapParams: r, swapQuotes: a }) => !r || !a ? {
+  supportedAsset: s,
+  withdrawData: "",
+  slippageTolerance: n
+} : ae({
+  assetAddress: s,
+  swapQuotes: a,
+  swapParams: r,
+  slippageToleranceForContractTransaction: n,
+  routerKey: e
+})), Se = async (t, e, n, s, r, a) => {
+  for (const o of t) {
+    const i = k(
+      Te(
+        e,
+        o,
+        n
+      ),
+      a
+    ), { error: c } = await s(...r, i);
+    if (!c)
+      return i;
+  }
+  return null;
+}, hn = (t, e, n) => {
+  const s = (t ?? []).map((r) => ({
+    supportedAsset: r,
+    withdrawData: "",
+    slippageTolerance: e
+  }));
+  return k(s, n);
+}, fn = async (t, e, n, s, r) => {
+  for (const a of t) {
+    const o = se(a);
+    try {
+      const i = await e(a), c = _e(
+        i
+      ), d = await Se(
+        c,
+        i,
+        o,
+        n,
+        s,
+        r
+      );
+      if (d)
+        return console.debug(
+          `[Init Withdraw] Auto slippage simulation succeeded: slippage=${a}%`
+        ), console.debug("[Init Withdraw] Complex asset data:", d), d;
+    } catch (i) {
+      console.error(
+        `[Init Withdraw] Failed to fetch quotes for slippage=${a}%:`,
+        i
+      );
+    }
+  }
+  return null;
+}, _n = async (t, e, {
+  fetchAaveSwapParams: n,
+  fetchAaveSwapQuotes: s,
+  withdrawAmountD18: r,
+  slippage: a
+}) => Promise.all(
+  (t ?? []).map(async (o) => {
+    if (!m(o, e))
+      return { asset: o };
+    try {
+      const c = await n({
+        withdrawAmountD18: r,
+        slippage: a
+      });
+      if (c?.srcData.length) {
+        const d = await s({
+          swapParams: c,
+          slippage: a
+        });
+        return { asset: o, swapParams: c, swapQuotes: d };
+      }
+      return { asset: o };
+    } catch (c) {
+      return console.error(c), { asset: o };
+    }
+  })
+), B = (t) => Math.round(t * 100) / 100, Tn = ({
+  maxSlippage: t,
+  candidates: e = Rt
+}) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return [];
+  const n = B(Math.min(t, 100)), s = e.filter((a) => a > 0 && a <= n).map(B), r = new Set(s);
+  return r.add(n), r.add(t), Array.from(r).sort((a, o) => a - o);
+}, x = 1000000000000000000n, we = 1000000n, P = 10000n, U = 100n, Sn = (t) => ({
+  quotes: t.quotes.map(
+    (e) => ({
+      chainId: p(e.chainId, "chainId"),
+      attestationId: p(e.attestationId, "attestationId"),
+      userId: g(e.userId),
+      asset: e.asset,
+      price: p(e.price, "price"),
+      quantity: p(e.quantity, "quantity"),
+      expiration: p(e.expiration, "expiration"),
+      side: Number(e.side),
+      additionalData: g(e.additionalData)
+    })
+  ),
+  signatures: t.signatures.map(g)
+}), De = (t, e, n) => {
+  const s = BigInt(Math.max(0, Math.round(n * 100))), r = s > U ? U : s, a = P - r, i = t * e / x * a * we, c = P * x;
+  return (i + c - 1n) / c;
+}, be = (t, e) => ({
+  chainId: e,
+  attestationId: p(t.attestationId, "attestationId"),
+  userId: R(t.userId),
+  asset: t.assetAddress,
+  price: p(t.price, "price"),
+  quantity: p(t.tokenAmount, "tokenAmount"),
+  expiration: p(t.expiration, "expiration"),
+  side: Number(t.side),
+  additionalData: R(t.additionalData)
+}), wn = ({
+  attestation: t,
+  chainId: e,
+  slippagePercent: n
+}) => {
+  const s = be(t, e);
+  return h(Lt, [
+    {
+      attestationSignature: Jt(t.signature),
+      quote: s,
+      amountOutMinimum: De(
+        s.quantity,
+        s.price,
+        n
+      )
+    }
+  ]);
+}, Dn = (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(
+    (r) => r.accountId === n && !r.isDebt
+  ),
+  debt: t.find(
+    (r) => r.accountId === n && r.isDebt
+  )
+})), bn = ({
+  collateral: t,
+  dytmOffice: e,
+  processor: n,
+  gmToken: s,
+  ondoGMSwap: r,
+  usdc: a,
+  gmAmount: o,
+  amountOutMinimum: i,
+  signature: c,
+  quote: d
+}) => [
+  {
+    // 1 · pull GM collateral out of the split account -> processor
+    to: e,
+    data: E({
+      abi: Y,
+      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: E({
+      abi: G,
+      functionName: "approve",
+      args: [r, o]
+    })
+  },
+  {
+    // 3 · redeem GM -> USDC with the signed attestation
+    to: r,
+    data: E({
+      abi: xt,
+      functionName: "swapExactInWithAttestation",
+      args: [s, o, a, i, c, d]
+    })
+  }
+], In = ({
+  accountId: t,
+  debtKey: e,
+  dytmOffice: n,
+  usdc: s
+}) => [
+  {
+    // approve USDC to the DYTM Office for the repay
+    to: s,
+    data: E({
+      abi: G,
+      functionName: "approve",
+      args: [n, I]
+    })
+  },
+  {
+    // repay the slice's whole USDC debt
+    to: n,
+    data: E({
+      abi: Y,
+      functionName: "repay",
+      args: [
+        {
+          account: t,
+          key: e,
+          withCollateralType: 0,
+          // DytmParamStructs.TokenType.NONE
+          assets: I,
+          // repay all
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  }
+], Nn = ({
+  actions: t,
+  outputAsset: e,
+  minOutputAmount: n
+}) => h(Pt, [
+  { actions: t, outputAsset: e, minOutputAmount: n }
+]);
+export {
+  He as $,
+  K as A,
+  Ge as B,
+  O as C,
+  un as D,
+  gn as E,
+  dn as F,
+  ln as G,
+  yn as H,
+  En as I,
+  Xe as J,
+  ne as K,
+  We as L,
+  qe as M,
+  se as N,
+  rn as O,
+  Dn as P,
+  $e as Q,
+  cn as R,
+  on as S,
+  mn as T,
+  An as U,
+  je as V,
+  ze as W,
+  pn as X,
+  be as Y,
+  Sn as Z,
+  k as _,
+  jt as a,
+  Ze as a0,
+  Ye as a1,
+  Fe as a2,
+  ke as a3,
+  ve as a4,
+  p as a5,
+  R as a6,
+  he as a7,
+  ge as a8,
+  Se as a9,
+  fn as aa,
+  Qe as ab,
+  Pe as ac,
+  Je as ad,
+  m as ae,
+  le as af,
+  tn as ag,
+  pe as ah,
+  Le as ai,
+  Me as aj,
+  fe as ak,
+  ye as al,
+  xe as am,
+  Ae as an,
+  me as ao,
+  en as ap,
+  M as aq,
+  Jt as b,
+  ae as c,
+  Te as d,
+  bn as e,
+  In as f,
+  ee as g,
+  Ve as h,
+  Ke as i,
+  Ce as j,
+  De as k,
+  hn as l,
+  wn as m,
+  Nn as n,
+  _n as o,
+  Be as p,
+  g as q,
+  _e as r,
+  zt as s,
+  Ee as t,
+  sn as u,
+  nn as v,
+  an as w,
+  Tn as x,
+  Ue as y,
+  te as z
+};