@dhedge/trading-widget 6.0.6 → 6.2.0-canary.0

package/dytm-DIQAbDy2.js

@@ -0,0 +1,833 @@
+import { mainnet as _, hyperEvm as G, polygon as V, optimism as K, base as Z, arbitrum as z } from "wagmi/chains";
+import { ar as Q, ap as X, aq as j, a as w, q as E, as as J, at as tt, a5 as et, al as nt, a3 as at, b as st, ae as ot, ak as rt, aj as it, Z as ut, au as $, e as ct, d as dt, M as pt, R as mt, P as lt, av as yt, aw as At, Q as Tt, N as ft, ah as g, _ as Dt, W as gt, X as St, U as _t, ax as W, ay as wt, az as Et, aA as It, aB as ht, aC as bt, ad as Nt } from "./gmx-D2b-KeY_.js";
+import d from "bignumber.js";
+import { zeroHash as Mt, bytesToHex as Ot, pad as Rt, stringToHex as I, encodeAbiParameters as f, encodeFunctionData as A, erc20Abi as q, maxUint256 as h } from "viem";
+const ye = typeof window < "u", Ae = [
+  {
+    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"
+  }
+], Ct = [
+  {
+    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" }
+], Te = [
+  {
+    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"
+  }
+], H = [
+  {
+    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"
+  }
+], Lt = [
+  {
+    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"
+  }
+], xt = [
+  {
+    type: "tuple",
+    components: [
+      {
+        name: "actions",
+        type: "tuple[]",
+        components: [
+          { name: "to", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "outputAsset", type: "address" },
+      { name: "minOutputAmount", type: "uint256" }
+    ]
+  }
+], Pt = () => typeof window < "u";
+function Ut() {
+  return Pt() && typeof window.ethereum < "u";
+}
+async function fe(t) {
+  try {
+    if (Ut())
+      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(), De = (t) => m(t, Q), T = (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`);
+  }
+}, b = (t) => t ? Rt(T(t), { size: 32 }) : Mt, Ft = (t) => {
+  if (!t) throw new Error("Cannot decode an empty base64 string");
+  return Ot(Uint8Array.from(atob(t), (e) => e.charCodeAt(0)));
+}, vt = (t, e) => j[e]?.[t] ?? w, ge = (t) => X[t], Se = (t) => t && `${t.substring(0, 6)}...${t.substring(
+  t.length - 4,
+  t.length
+)}`, _e = ({
+  address: t,
+  chainId: e
+}) => {
+  const n = vt(
+    "aaveLendingPoolV3",
+    e
+  );
+  return m(t, n);
+}, $t = ({
+  sourceAddress: t,
+  amount: e
+}) => `${t}_${e}`, we = (t, e) => {
+  const n = t.slice(0, e), a = t.slice(e);
+  return { firstPart: n, secondPart: a };
+}, Wt = (t, e) => t / e * 100, Ee = (t) => t < 1 ? 4 : t < 10 ? 3 : 2, Ie = (t, e = E) => new d(t.toString()).shiftedBy(e).toFixed(0), he = (t, e, n, a) => new d(e).dividedBy(n).multipliedBy(t).shiftedBy(-(a || E)).toNumber(), be = (t) => BigInt(
+  new d(t || "0").shiftedBy(E).toFixed(0, d.ROUND_DOWN)
+), qt = (t) => {
+  const e = new d(0.01), n = new d(t), a = !n.isZero() && n.lt(e) ? e : n;
+  return BigInt(a.multipliedBy(100).toFixed(0));
+}, Ne = ({
+  vaultAddress: t,
+  swapData: e,
+  sendTokenAddress: n,
+  sendTokenAmount: a,
+  vaultDepositTokenAddress: s,
+  minVaultTokensReceivedAmount: o,
+  routerKey: r = "ONE_INCH",
+  swapDestinationAmount: u,
+  swapSlippage: i
+}) => {
+  const c = new d(u).multipliedBy(1 - i / 100).toFixed(0), l = [I(r, { size: 32 }), e];
+  return [t, [[n, a, l], [s, c]], o];
+}, Me = ({
+  receiveAssetAddress: t,
+  assets: e,
+  swapData: n,
+  slippage: a
+}) => {
+  const s = {
+    srcData: [],
+    destAmount: new d("0")
+  }, { srcData: o, destAmount: r } = e?.reduce((u, i) => {
+    const c = n?.[i.address];
+    if (!c)
+      return u;
+    const l = [
+      I(c.routerKey, { size: 32 }),
+      c.rawTransaction.data
+    ], y = [i.address, i.rawBalance, l];
+    return {
+      srcData: [...u.srcData, y],
+      destAmount: u.destAmount.plus(c.destinationAmount)
+    };
+  }, s) ?? s;
+  return [
+    o,
+    [
+      t,
+      r.times(1 - a / 100).toFixed(0, d.ROUND_DOWN)
+    ]
+  ];
+}, Ht = ({
+  assetAddress: t,
+  swapQuotes: e,
+  swapParams: n,
+  slippageToleranceForContractTransaction: a,
+  routerKey: s
+}) => {
+  if (!n)
+    return {
+      supportedAsset: t,
+      withdrawData: "",
+      slippageTolerance: BigInt(0)
+    };
+  const { srcData: o, dstData: r } = n, u = o.map(({ asset: l, amount: y }) => {
+    const D = e?.[$t({
+      sourceAddress: l,
+      amount: y.toString()
+    })]?.find((k) => k.routerKey === s);
+    return {
+      asset: l,
+      amount: y,
+      swapData: {
+        routerKey: I(D?.routerKey ?? "", { size: 32 }),
+        txData: D?.rawTransaction.data ?? "0x"
+      }
+    };
+  }), i = f(
+    J,
+    [u]
+  ), c = f(tt, [
+    {
+      encodedSrcData: i,
+      dstData: {
+        dstAddress: r.asset,
+        dstAmount: r.amount
+      },
+      slippage: a
+    }
+  ]);
+  return {
+    supportedAsset: t,
+    withdrawData: c,
+    slippageTolerance: a
+  };
+}, Oe = ({
+  chainId: t,
+  txHash: e,
+  error: n
+}) => {
+  if (t !== _.id || !e || !n)
+    return !1;
+  const a = n instanceof Error ? n.message : String(n);
+  return /\bNo Result\b/i.test(a);
+}, Re = ({
+  chainId: t,
+  action: e,
+  isRabbyWallet: n
+}) => e === "update_ondo_prices" && t === _.id && n ? et : t ? nt[t] ?? 0 : 0, Ce = (t, e) => st[e]?.nativeTokenSymbol === t, Be = ({
+  nativeTokenBalance: t,
+  tokenDecimals: e,
+  gasPrice: n
+}) => {
+  const a = new d(n).multipliedBy(at).shiftedBy(-e), s = new d(t).minus(
+    a
+  );
+  return s.gt("0") ? s : new d("0");
+}, Le = (t) => ot.includes(t), xe = (t) => {
+  const e = Object.values(t).reduce(
+    (n, { type: a }) => (n[a] = n[a] + 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;
+}, Yt = (t, e = 150) => t.length > e ? t.substring(0, e) : t, kt = (t) => !!t?.includes("User rejected"), N = (t, e = rt) => {
+  const n = t.toLowerCase();
+  return e.sort((a, s) => s.length - a.length).find((a) => n.includes(a.toLowerCase()));
+}, M = (t) => it[t] ?? ut[t], Pe = ({
+  errorMessage: t,
+  abiErrors: e
+}) => {
+  if (!t || kt(t))
+    return null;
+  const n = e.find((o) => t.includes(o));
+  if (n && N(n))
+    return M(n);
+  const a = N(t);
+  if (a)
+    return M(a);
+  const [s] = t.split(n ? "." : "Contract").map((o) => o.trim());
+  return {
+    title: "Transaction failed",
+    hint: `${Yt(s ?? "")} ${n ? `: ${n}` : ""}`
+  };
+}, Ue = (t) => typeof t == "number" && Number.isFinite(t), Fe = (t) => typeof t == "bigint" && t !== BigInt(0), Gt = (t, e = $) => new d(t).shiftedBy(-e).toNumber(), Vt = (t) => !isNaN(parseFloat(t)) && !isNaN(t), Kt = ({
+  value: t,
+  minimumFractionDigits: e = 2,
+  maximumFractionDigits: n = 2,
+  compact: a = !1,
+  normalize: s = !1
+}) => new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  notation: a ? "compact" : void 0,
+  minimumFractionDigits: e,
+  maximumFractionDigits: n
+}).format(s ? Gt(t) : Number(t)), O = (t) => Vt(t) ? new d(t).toFixed() : "", R = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"], Zt = ({
+  value: t,
+  decimals: e = 4
+}) => {
+  const n = new d(t);
+  if (n.isGreaterThan(1) || n.isZero())
+    return O(n.toFixed(e));
+  const s = (/e/i.test(t.toString()) ? parseFloat(t.toString()).toFixed($) : t.toString()).match(/^0\.(0+)(\d+)$/);
+  if (s) {
+    const [, o, r] = s;
+    if (o.length >= e && o.length < R.length)
+      return `0.0${R[o.length]}${r.slice(0, 3)}`;
+  }
+  return O(n.toFixed(e));
+}, zt = (t, e = 0) => `${t.toLocaleString("en-US", { maximumFractionDigits: e })}%`, ve = (t) => t.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), $e = (t, e, n = 0) => {
+  const a = Wt(+t, e);
+  return zt(a, n);
+}, We = ({
+  currency: t,
+  value: e
+}) => t === "USD" ? Kt({ value: e }) : `${ct[t]} ${Zt({
+  value: e,
+  decimals: dt[t]
+})}`, Qt = (t, e) => new d(
+  new d(t).toFixed(e, d.ROUND_DOWN)
+).toString(), Xt = (t, e = 3, n = 2) => {
+  if (t.length <= 5)
+    return t;
+  const a = "...";
+  return t.length <= e + n + a.length ? t : `${t.slice(0, e)}${a}${t.slice(-n)}`;
+}, qe = ({
+  balance: t,
+  symbol: e,
+  precision: n,
+  truncateSymbol: a
+}) => `${Qt(t, n)} ${a ? Xt(e) : e}`, He = (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)}`;
+}, Ye = (t) => m(yt, t) || m(At, t), ke = (t) => ft.some(
+  (e) => m(e, t)
+), Ge = (t) => pt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: w
+}, Ve = (t) => m(t, Tt) ? mt : lt, jt = (t) => `eth_${t}`, Ke = ({
+  action: t,
+  log: e,
+  symbol: n,
+  vaultAddress: a,
+  chainId: s
+}) => {
+  const o = {
+    [g.SYMBOL.NAME]: n,
+    [g.CHAIN_ID.NAME]: s,
+    [g.ADDRESS.NAME]: jt(a)
+  };
+  Dt[t].forEach((r) => {
+    e?.(r, o);
+  });
+}, Ze = (t) => _t.some((e) => m(e, t)), ze = (t) => gt[t.toLowerCase()] ?? {
+  symbol: "",
+  decimals: 18,
+  address: w
+}, Qe = (t) => St[t.toLowerCase()], Jt = "0x3333333333333333333333333333333333333333";
+z.id + "", bt.address, Z.id + "", ht.address, K.id + "", It.address, V.id + "", Et.address, _.id + "", wt.address, G.id + "", W.address;
+const Xe = (t) => m(t, Jt), je = () => W, te = 1e5, ee = 1e4, ne = 1e4, C = 0, ae = 4294967295;
+class S extends Error {
+  constructor(e) {
+    super(e), this.name = "HyperliquidAssetIdMappingError";
+  }
+}
+const B = (t) => {
+  const e = Number(t);
+  return Number.isFinite(e) && e !== 0;
+}, L = (t, e) => {
+  if (!Number.isInteger(t) || t < 0 || t > ae)
+    throw new S(
+      `Asset id ${t} for ${e} is out of uint32 range`
+    );
+  return t;
+}, x = (t) => [...new Set(t)].sort((e, n) => e - n), Je = ({
+  perpDexStates: t,
+  spotBalances: e,
+  spotPairs: n
+}) => {
+  const a = t.flatMap(
+    ({ dexId: o, positions: r, universe: u }) => r.filter(({ szi: i }) => B(i)).map(({ coin: i }) => {
+      const c = u.findIndex(({ name: y }) => y === i);
+      if (c === -1)
+        throw new S(
+          `Open perp position "${i}" not found in dex ${o} universe`
+        );
+      const l = o === 0 ? c : te + o * ee + c;
+      return L(l, `perp "${i}"`);
+    })
+  ), s = e.filter(
+    ({ token: o, total: r }) => o !== C && B(r)
+  ).map(({ coin: o, token: r }) => {
+    const u = n.find(
+      ({ tokens: i }) => i[0] === r && i[1] === C
+    );
+    if (!u)
+      throw new S(
+        `No token/USDC spot pair found for held spot token "${o}" (index ${r})`
+      );
+    return L(ne + u.index, `spot "${o}"`);
+  });
+  return {
+    perpAssetIds: x(a),
+    spotAssetIds: x(s)
+  };
+}, tn = /* @__PURE__ */ new Map(), Y = (t, e) => !e || e.size === 0 ? t : t.map((n) => {
+  const a = e.get(
+    n.supportedAsset.toLowerCase()
+  );
+  return a ? {
+    ...n,
+    withdrawData: a.withdrawData,
+    slippageTolerance: a.slippageTolerance
+  } : n;
+}), se = (t) => {
+  const e = t.find(
+    ({ swapQuotes: n }) => n
+  );
+  return e?.swapQuotes ? Object.values(e.swapQuotes)[0]?.map(
+    ({ routerKey: n }) => n
+  ) ?? [] : [];
+}, oe = (t, e, n) => t.map(({ asset: a, swapParams: s, swapQuotes: o }) => !s || !o ? {
+  supportedAsset: a,
+  withdrawData: "",
+  slippageTolerance: n
+} : Ht({
+  assetAddress: a,
+  swapQuotes: o,
+  swapParams: s,
+  slippageToleranceForContractTransaction: n,
+  routerKey: e
+})), re = async (t, e, n, a, s, o) => {
+  for (const r of t) {
+    const u = Y(
+      oe(
+        e,
+        r,
+        n
+      ),
+      o
+    ), { error: i } = await a(...s, u);
+    if (!i)
+      return u;
+  }
+  return null;
+}, en = (t, e, n) => {
+  const a = (t ?? []).map((s) => ({
+    supportedAsset: s,
+    withdrawData: "",
+    slippageTolerance: e
+  }));
+  return Y(a, n);
+}, nn = async (t, e, n, a, s) => {
+  for (const o of t) {
+    const r = qt(o);
+    try {
+      const u = await e(o), i = se(
+        u
+      ), c = await re(
+        i,
+        u,
+        r,
+        n,
+        a,
+        s
+      );
+      if (c)
+        return console.debug(
+          `[Init Withdraw] Auto slippage simulation succeeded: slippage=${o}%`
+        ), console.debug("[Init Withdraw] Complex asset data:", c), c;
+    } catch (u) {
+      console.error(
+        `[Init Withdraw] Failed to fetch quotes for slippage=${o}%:`,
+        u
+      );
+    }
+  }
+  return null;
+}, an = async (t, e, {
+  fetchAaveSwapParams: n,
+  fetchAaveSwapQuotes: a,
+  withdrawAmountD18: s,
+  slippage: o
+}) => Promise.all(
+  (t ?? []).map(async (r) => {
+    if (!m(r, e))
+      return { asset: r };
+    try {
+      const i = await n({
+        withdrawAmountD18: s,
+        slippage: o
+      });
+      if (i?.srcData.length) {
+        const c = await a({
+          swapParams: i,
+          slippage: o
+        });
+        return { asset: r, swapParams: i, swapQuotes: c };
+      }
+      return { asset: r };
+    } catch (i) {
+      return console.error(i), { asset: r };
+    }
+  })
+), P = (t) => Math.round(t * 100) / 100, sn = ({
+  maxSlippage: t,
+  candidates: e = Nt
+}) => {
+  if (!Number.isFinite(t) || t <= 0)
+    return [];
+  const n = P(Math.min(t, 100)), a = e.filter((o) => o > 0 && o <= n).map(P), s = new Set(a);
+  return s.add(n), s.add(t), Array.from(s).sort((o, r) => o - r);
+}, U = 1000000000000000000n, ie = 1000000n, F = 10000n, v = 100n, on = (t) => ({
+  quotes: t.quotes.map(
+    (e) => ({
+      chainId: p(e.chainId, "chainId"),
+      attestationId: p(e.attestationId, "attestationId"),
+      userId: T(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: T(e.additionalData)
+    })
+  ),
+  signatures: t.signatures.map(T)
+}), ue = (t, e, n) => {
+  const a = BigInt(Math.max(0, Math.round(n * 100))), s = a > v ? v : a, o = F - s, u = t * e / U * o * ie, i = F * U;
+  return (u + i - 1n) / i;
+}, ce = (t, e) => ({
+  chainId: e,
+  attestationId: p(t.attestationId, "attestationId"),
+  userId: b(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: b(t.additionalData)
+}), rn = ({
+  attestation: t,
+  chainId: e,
+  slippagePercent: n
+}) => {
+  const a = ce(t, e);
+  return f(Ct, [
+    {
+      attestationSignature: Ft(t.signature),
+      quote: a,
+      amountOutMinimum: ue(
+        a.quantity,
+        a.price,
+        n
+      )
+    }
+  ]);
+}, un = (t) => [...t.reduce(
+  (n, a) => n.has(a.accountId) ? n : n.set(a.accountId, a),
+  /* @__PURE__ */ new Map()
+).values()].map(({ accountId: n, marketId: a }) => ({
+  accountId: n,
+  marketId: a,
+  collaterals: t.filter(
+    (s) => s.accountId === n && !s.isDebt
+  ),
+  debt: t.find(
+    (s) => s.accountId === n && s.isDebt
+  )
+})), cn = ({
+  collateral: t,
+  dytmOffice: e,
+  processor: n,
+  gmToken: a,
+  ondoGMSwap: s,
+  usdc: o,
+  gmAmount: r,
+  amountOutMinimum: u,
+  signature: i,
+  quote: c
+}) => [
+  {
+    // 1 · pull GM collateral out of the split account -> processor
+    to: e,
+    data: A({
+      abi: H,
+      functionName: "withdraw",
+      args: [
+        {
+          account: t.accountId,
+          tokenId: t.tokenId,
+          receiver: n,
+          assets: r,
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  },
+  {
+    // 2 · approve the GM token to Ondo's swap contract
+    to: a,
+    data: A({
+      abi: q,
+      functionName: "approve",
+      args: [s, r]
+    })
+  },
+  {
+    // 3 · redeem GM -> USDC with the signed attestation
+    to: s,
+    data: A({
+      abi: Lt,
+      functionName: "swapExactInWithAttestation",
+      args: [a, r, o, u, i, c]
+    })
+  }
+], dn = ({
+  accountId: t,
+  debtKey: e,
+  dytmOffice: n,
+  usdc: a
+}) => [
+  {
+    // approve USDC to the DYTM Office for the repay
+    to: a,
+    data: A({
+      abi: q,
+      functionName: "approve",
+      args: [n, h]
+    })
+  },
+  {
+    // repay the slice's whole USDC debt
+    to: n,
+    data: A({
+      abi: H,
+      functionName: "repay",
+      args: [
+        {
+          account: t,
+          key: e,
+          withCollateralType: 0,
+          // DytmParamStructs.TokenType.NONE
+          assets: h,
+          // repay all
+          shares: 0n,
+          extraData: "0x"
+        }
+      ]
+    })
+  }
+], pn = ({
+  actions: t,
+  outputAsset: e,
+  minOutputAmount: n
+}) => f(xt, [
+  { actions: t, outputAsset: e, minOutputAmount: n }
+]);
+export {
+  Pe as $,
+  Ge as A,
+  Ve as B,
+  ze as C,
+  Qe as D,
+  tn as E,
+  je as F,
+  Be as G,
+  S as H,
+  Wt as I,
+  he as J,
+  Re as K,
+  qt as L,
+  He as M,
+  un as N,
+  _e as O,
+  ke as P,
+  Ye as Q,
+  Ze as R,
+  Xe as S,
+  Ce as T,
+  Le as U,
+  kt as V,
+  Ke as W,
+  ce as X,
+  on as Y,
+  Y as Z,
+  be as _,
+  Ht as a,
+  Ie as a0,
+  Se as a1,
+  Oe as a2,
+  we as a3,
+  p as a4,
+  b as a5,
+  jt as a6,
+  Xt as a7,
+  re as a8,
+  nn as a9,
+  xe as aa,
+  De as ab,
+  Ue as ac,
+  m as ad,
+  Kt as ae,
+  Fe as af,
+  Gt as ag,
+  Te as ah,
+  Ae as ai,
+  Jt as aj,
+  Zt as ak,
+  fe as al,
+  zt as am,
+  Vt as an,
+  ve as ao,
+  O as ap,
+  Ft as b,
+  oe as c,
+  cn as d,
+  dn as e,
+  Je as f,
+  $t as g,
+  Me as h,
+  Ne as i,
+  ye as j,
+  ue as k,
+  en as l,
+  rn as m,
+  pn as n,
+  an as o,
+  T as p,
+  se as q,
+  Qt as r,
+  We as s,
+  $e as t,
+  qe as u,
+  sn as v,
+  ge as w,
+  vt as x,
+  Ee as y,
+  N as z
+};