@latchprotocol/widgets 0.1.0

package/dist/chunks/scan-Dhu7f4Nl.js

@@ -0,0 +1,2497 @@
+import { createContext as In, useMemo as N, useEffect as z, useContext as Ze, useState as I, useRef as fe, useCallback as y } from "react";
+import { isAddress as xe, getAddress as Qe, formatUnits as ze, parseUnits as vn, concatHex as Tn, encodeAbiParameters as P, isAddressEqual as R, encodeFunctionData as En, decodeErrorResult as An, BaseError as Je, parseAbi as Ln, zeroAddress as W, keccak256 as Sn, erc20Abi as qe } from "viem";
+import { LAUNCH_GUARD_HOOK_ABI as en, LAUNCH_GUARD_HOOK_BLOCK_ABI as $n, UNIVERSAL_ROUTER_ABI as Bn, CL_QUOTER_ABI as Pn, BIN_QUOTER_ABI as Nn, CL_POSITION_MANAGER_ABI as On, BIN_POSITION_MANAGER_ABI as xn, BIN_LAUNCH_GUARD_HOOK_ABI as _n, readBinPoolKeyParameters as Rn, readCLPoolKeyParameters as Cn, ipfsToHttp as Mn, mergeTokenLists as nn, stockExtensionOf as Fn, fetchTokenList as qn } from "@latchprotocol/sdk";
+import { LATCH_POSITION_LOCK_ABI as Un, LATCH_TOKEN_LOCK_ABI as Dn, readBinPoolPermanent as Gn, readChainNow as Ie, summarizePoolLocks as Ue, readPoolLocks as Wn, readClPoolPermanent as Kn, readCurrencyLocks as Hn, readClLpLockerPositionsPriced as Xn, readBinLpLockerLocks as Vn, permanentTokenPools as jn, findClLpLockerTokenIds as tn, vestedAt as Yn } from "@latchprotocol/sdk/lock";
+import { jsx as Zn } from "react/jsx-runtime";
+class G extends Error {
+  chainId;
+  contract;
+  constructor(n, t, o = null) {
+    super(`[@latchprotocol/widgets] ${n}`), this.name = "ChainConfigError", this.chainId = t, this.contract = o;
+  }
+}
+const Qn = "0x0000000000000000000000000000000000000000";
+function on(e, n, t, o) {
+  if (typeof e != "string" || !xe(e))
+    throw new G(
+      `chain ${t}: ${n} is not a valid address: ${JSON.stringify(e)}`,
+      t,
+      o
+    );
+  const r = Qe(e);
+  if (r === Qn)
+    throw new G(
+      `chain ${t}: ${n} is the zero address. Pass the deployed address from the address book.`,
+      t,
+      o
+    );
+  return r;
+}
+function zn(e) {
+  if (!Number.isInteger(e.chainId) || e.chainId <= 0)
+    throw new G(
+      `chainId must be a positive integer, received ${String(e.chainId)}`,
+      Number(e.chainId) || 0
+    );
+  if (e.nativeCurrency.decimals < 0 || e.nativeCurrency.decimals > 36)
+    throw new G(
+      `nativeCurrency.decimals is out of range: ${e.nativeCurrency.decimals}`,
+      e.chainId
+    );
+  if (on(e.contracts.vault, "contracts.vault", e.chainId, "vault"), !e.contracts.clPoolManager && !e.contracts.binPoolManager)
+    throw new G(
+      `chain ${e.chainId}: at least one of contracts.clPoolManager or contracts.binPoolManager must be set`,
+      e.chainId
+    );
+}
+function wo(e, n, t) {
+  const o = e.contracts[n];
+  if (o === void 0)
+    throw new G(
+      `chain ${e.chainId} (${e.name}): contracts.${n} is not configured, but it is required to ${t}.`,
+      e.chainId,
+      n
+    );
+  return on(o, `contracts.${n}`, e.chainId, n);
+}
+function bo(e, n) {
+  return e === null ? n : n === null || e > n ? e : n;
+}
+function he(e, n) {
+  const t = BigInt(e.defaultDeadlineSeconds ?? 1200), o = BigInt(Math.floor(Date.now() / 1e3)), r = n === void 0 ? o : BigInt(n);
+  return (r > o ? r : o) + t;
+}
+async function _e(e, n) {
+  if (n.getBlockTimestamp === void 0) return he(e);
+  try {
+    return he(e, await n.getBlockTimestamp());
+  } catch {
+    return he(e);
+  }
+}
+function ko(e, n) {
+  const t = (e.blockExplorerUrl ?? "").trim().replace(/\/+$/, "");
+  return t === "" ? null : `${t}/tx/${n}`;
+}
+const me = 1e4, J = 100, ae = "0x0000000000000000000000000000000000000000";
+class F extends Error {
+  code;
+  constructor(n, t) {
+    super(`[@latchprotocol/widgets] integrator config rejected (${n}): ${t}`), this.name = "IntegratorConfigError", this.code = n;
+  }
+}
+const rn = ["take-portion", "pay-portion"];
+function Jn(e) {
+  return rn.includes(e);
+}
+function et(e) {
+  const { feeBps: n } = e;
+  if (typeof n != "number" || Number.isNaN(n))
+    throw new F(
+      "FEE_BPS_NOT_A_NUMBER",
+      `feeBps must be a number, received ${JSON.stringify(n)}`
+    );
+  if (!Number.isFinite(n) || !Number.isInteger(n))
+    throw new F(
+      "FEE_BPS_NOT_AN_INTEGER",
+      `feeBps must be a whole number of basis points, received ${n}. There is no sub-basis-point precision on-chain.`
+    );
+  if (n < 0)
+    throw new F(
+      "FEE_BPS_NEGATIVE",
+      `feeBps must not be negative, received ${n}`
+    );
+  if (n > J)
+    throw new F(
+      "FEE_BPS_ABOVE_MAX",
+      `feeBps ${n} exceeds MAX_INTEGRATOR_FEE_BPS (${J} bps = ${J / 100}%). Raise it only by forking this package and owning the consequences for your users.`
+    );
+  const t = e.feeMode ?? "take-portion";
+  if (!Jn(t))
+    throw new F(
+      "FEE_MODE_UNKNOWN",
+      `feeMode must be one of ${rn.join(" | ")}, received ${JSON.stringify(t)}`
+    );
+  const o = [], r = e.referrer, s = n > 0;
+  if (r == null || r === "") {
+    if (s)
+      throw new F(
+        "REFERRER_MISSING",
+        `feeBps is ${n} but no referrer address was provided. A fee with no destination would be silently forfeited; refusing to build the call path.`
+      );
+    return {
+      referrer: ae,
+      feeBps: 0,
+      feeMode: t,
+      label: e.label ?? null,
+      active: !1,
+      warnings: o
+    };
+  }
+  if (typeof r != "string" || !xe(r))
+    throw new F(
+      "REFERRER_MALFORMED",
+      `referrer is not a valid EVM address: ${JSON.stringify(r)}`
+    );
+  const i = Qe(r);
+  if (i === ae) {
+    if (s)
+      throw new F(
+        "REFERRER_ZERO_ADDRESS",
+        `feeBps is ${n} but referrer is the zero address. The fee would be burned.`
+      );
+    return {
+      referrer: ae,
+      feeBps: 0,
+      feeMode: t,
+      label: e.label ?? null,
+      active: !1,
+      warnings: o
+    };
+  }
+  return s || o.push(
+    `referrer ${i} is configured but feeBps is 0, so this widget will earn the integrator nothing. Set feeBps to start collecting.`
+  ), {
+    referrer: i,
+    feeBps: n,
+    feeMode: t,
+    label: e.label ?? null,
+    active: s,
+    warnings: o
+  };
+}
+const nt = {
+  referrer: ae,
+  feeBps: 0,
+  feeMode: "take-portion",
+  label: null,
+  active: !1,
+  warnings: []
+};
+function tt(e) {
+  return e == null ? nt : et(e);
+}
+function Re(e, n) {
+  if (e < 0n)
+    throw new RangeError(`calculateIntegratorFee: grossAmount must not be negative: ${e}`);
+  if (!Number.isInteger(n) || n < 0 || n > me)
+    throw new RangeError(
+      `calculateIntegratorFee: feeBps must be an integer in [0, ${me}]: ${n}`
+    );
+  return e * BigInt(n) / BigInt(me);
+}
+function ot(e, n) {
+  if (!n.active)
+    return {
+      grossAmount: e,
+      integratorFee: 0n,
+      netAmount: e,
+      feeBps: 0,
+      referrer: null
+    };
+  const t = Re(e, n.feeBps);
+  return {
+    grossAmount: e,
+    integratorFee: t,
+    netAmount: e - t,
+    feeBps: n.feeBps,
+    referrer: n.referrer
+  };
+}
+function go(e) {
+  const n = e / 100;
+  return `${Number.isInteger(n) ? n.toString() : n.toFixed(2)}%`;
+}
+const U = 10000n, rt = 1000000n, _ = 5e3, st = 50, it = 300, at = 1e3;
+function K(e, n) {
+  if (e < 0n) throw new RangeError(`${n} must not be negative: ${e}`);
+}
+function oe(e, n, t) {
+  if (!Number.isInteger(e) || e < 0 || e > t)
+    throw new RangeError(`${n} must be an integer in [0, ${t}]: ${e}`);
+}
+function Io(e, n) {
+  return K(e, "amount"), oe(n, "bps", 1e4), e * BigInt(n) / U;
+}
+function vo(e, n) {
+  return K(e, "amount"), oe(n, "pips", 1e6), e * BigInt(n) / rt;
+}
+function ve(e, n) {
+  return K(e, "expected"), oe(n, "slippageBps", _), e * (U - BigInt(n)) / U;
+}
+function De(e, n) {
+  K(e, "expected"), oe(n, "slippageBps", _);
+  const t = e * (U + BigInt(n));
+  return t % U === 0n ? t / U : t / U + 1n;
+}
+function ut(e, n) {
+  if (n == null || n <= 0n) return null;
+  if (K(e, "grossAmountOut"), e >= n) return 0;
+  const t = (n - e) * U / n;
+  return Number(t);
+}
+function lt(e) {
+  return e === null ? "unknown" : e >= at ? "severe" : e >= it ? "high" : e >= 100 ? "elevated" : "low";
+}
+function ct(e) {
+  const { amountIn: n, grossAmountOut: t, slippageBps: o, integrator: r } = e;
+  K(n, "amountIn"), K(t, "grossAmountOut"), oe(o, "slippageBps", _);
+  const s = ot(t, r), i = ve(t, o), u = r.active ? i - Re(i, r.feeBps) : i, a = ut(t, e.spotAmountOut ?? null);
+  return {
+    amountIn: n,
+    grossAmountOut: t,
+    integratorFee: s.integratorFee,
+    integratorFeeBps: s.feeBps,
+    netAmountOut: s.netAmount,
+    minAmountOutGross: i,
+    minAmountOutNet: u,
+    lpFeeAmount: e.lpFeeAmount ?? 0n,
+    lpFeePips: e.lpFeePips ?? 0,
+    lpFeeUnknown: e.lpFeeUnknown ?? !1,
+    slippageBps: o,
+    priceImpactBps: a,
+    priceImpactSeverity: lt(a)
+  };
+}
+function dt(e, n, t, o) {
+  if (e <= 0n || t <= 0n) return null;
+  const r = Number(e) / 10 ** n, s = Number(t) / 10 ** o;
+  return !Number.isFinite(r) || r === 0 ? null : s / r;
+}
+function To(e, n) {
+  if (n <= 0n) return 0;
+  const t = e > n ? n : e;
+  return Number(t * 10000n / n) / 100;
+}
+function Eo(e, n, t) {
+  if (n > t) throw new RangeError(`clampBigInt: min ${n} exceeds max ${t}`);
+  return e < n ? n : e > t ? t : e;
+}
+function pt(e, n) {
+  if (!Number.isInteger(n) || n <= 0)
+    throw new RangeError(`tickSpacing must be a positive integer: ${n}`);
+  return Math.floor(e / n) * n;
+}
+function ft(e, n) {
+  if (!Number.isInteger(n) || n <= 0)
+    throw new RangeError(`tickSpacing must be a positive integer: ${n}`);
+  return Math.ceil(e / n) * n;
+}
+const Ce = In(null);
+function Ao(e) {
+  const {
+    adapter: n,
+    integrator: t,
+    defaultSlippageBps: o = st,
+    theme: r = "system",
+    locale: s,
+    onConnectRequest: i,
+    children: u
+  } = e, a = N(
+    () => tt(t ?? null),
+    [t]
+  ), l = n.chain;
+  if (N(() => (zn(l), null), [l]), !Number.isInteger(o) || o < 0)
+    throw new RangeError(
+      `[@latchprotocol/widgets] defaultSlippageBps must be a non-negative integer: ${o}`
+    );
+  if (o > _)
+    throw new RangeError(
+      `[@latchprotocol/widgets] defaultSlippageBps ${o} exceeds MAX_SLIPPAGE_BPS (${_})`
+    );
+  z(() => {
+    for (const d of a.warnings)
+      console.warn(`[@latchprotocol/widgets] ${d}`);
+  }, [a]);
+  const c = N(
+    () => ({
+      adapter: n,
+      chain: l,
+      integrator: a,
+      defaultSlippageBps: o,
+      theme: r,
+      locale: s,
+      onConnectRequest: i
+    }),
+    [n, l, a, o, r, s, i]
+  );
+  return /* @__PURE__ */ Zn(Ce.Provider, { value: c, children: u });
+}
+function E() {
+  const e = Ze(Ce);
+  if (e === null)
+    throw new Error(
+      "[@latchprotocol/widgets] no WidgetProvider found. Wrap your app (or just the widget) in <WidgetProvider adapter={...} integrator={...}>."
+    );
+  return e;
+}
+function Lo() {
+  return Ze(Ce);
+}
+function So() {
+  return E().adapter;
+}
+function $o() {
+  return E().integrator;
+}
+const ht = /^\d*(?:\.\d*)?$/;
+function Bo(e, n, t = !1) {
+  const o = e.trim();
+  if (o === "" || o === ".")
+    return { ok: !1, reason: "empty", message: "Enter an amount" };
+  if (o.startsWith("-"))
+    return { ok: !1, reason: "negative", message: "Amount must be positive" };
+  if (!ht.test(o))
+    return { ok: !1, reason: "not-a-number", message: "Amount must be a number" };
+  const [, r = ""] = o.split(".");
+  if (r.length > n)
+    return {
+      ok: !1,
+      reason: "too-many-decimals",
+      message: `This token has ${n} decimals; ${r.length} were entered`
+    };
+  const s = vn(o, n);
+  return s === 0n && !t ? { ok: !1, reason: "zero", message: "Enter an amount greater than zero" } : { ok: !0, value: s };
+}
+function Po(e, n, t = 6) {
+  if (e === 0n) return "0";
+  const o = e < 0n, r = ze(o ? -e : e, n), [s = "0", i = ""] = r.split("."), u = o ? "-" : "";
+  if (i === "") return `${u}${ye(s)}`;
+  const a = i.slice(0, t).replace(/0+$/, "");
+  if (a === "") {
+    if (s === "0") {
+      const l = `0.${"0".repeat(Math.max(0, t - 1))}1`;
+      return `${u}<${l}`;
+    }
+    return `${u}${ye(s)}`;
+  }
+  return `${u}${ye(s)}.${a}`;
+}
+function ye(e) {
+  return e.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function No(e, n, t) {
+  if (e === null || !Number.isFinite(e) || e <= 0) return "-";
+  const o = e >= 1e3 ? 2 : e >= 1 ? 4 : 6;
+  return `1 ${n} = ${e.toLocaleString(void 0, {
+    maximumFractionDigits: o
+  })} ${t}`;
+}
+function Oo(e) {
+  if (e === null) return "unknown";
+  const n = e / 100;
+  return n > 0 && n < 0.01 ? "<0.01%" : `${n.toFixed(2)}%`;
+}
+function mt(e) {
+  const n = e / 1e4;
+  return n > 0 && n < 1e-3 ? "<0.001%" : `${yt(n.toFixed(3))}%`;
+}
+function yt(e) {
+  return e.includes(".") ? e.replace(/\.?0+$/, "") : e;
+}
+function wt(e) {
+  return e.length <= 12 ? e : `${e.slice(0, 6)}...${e.slice(-4)}`;
+}
+function xo(e) {
+  if (!Number.isFinite(e) || e <= 0) return "0s";
+  const n = Math.floor(e), t = Math.floor(n / 86400), o = Math.floor(n % 86400 / 3600), r = Math.floor(n % 3600 / 60), s = n % 60, i = [];
+  return t > 0 && i.push(`${t}d`), o > 0 && i.push(`${o}h`), r > 0 && t === 0 && i.push(`${r}m`), i.length === 0 && i.push(`${s}s`), i.join(" ");
+}
+function _o(e) {
+  const n = Number(e) * 1e3;
+  return Number.isFinite(n) ? new Date(n).toLocaleString() : "-";
+}
+const we = {
+  SWEEP: 4,
+  TRANSFER: 5,
+  /** Pays a bps portion of the router's balance of a token to a recipient. */
+  PAY_PORTION: 6,
+  WRAP_ETH: 11,
+  UNWRAP_WETH: 12,
+  /** Runs an encoded periphery action plan inside one vault lock. */
+  INFI_SWAP: 16
+}, O = {
+  CL_INCREASE_LIQUIDITY: 0,
+  CL_DECREASE_LIQUIDITY: 1,
+  CL_MINT_POSITION: 2,
+  CL_BURN_POSITION: 3,
+  CL_SWAP_EXACT_IN_SINGLE: 6,
+  CL_SWAP_EXACT_IN: 7,
+  CL_SWAP_EXACT_OUT_SINGLE: 8,
+  CL_SWAP_EXACT_OUT: 9,
+  SETTLE: 11,
+  SETTLE_ALL: 12,
+  SETTLE_PAIR: 13,
+  TAKE: 14,
+  TAKE_ALL: 15,
+  /** Takes a bps portion of the open credit straight to a recipient. */
+  TAKE_PORTION: 16,
+  TAKE_PAIR: 17,
+  CLOSE_CURRENCY: 18,
+  CLEAR_OR_TAKE: 19,
+  SWEEP: 20,
+  BIN_ADD_LIQUIDITY: 25,
+  BIN_REMOVE_LIQUIDITY: 26,
+  BIN_SWAP_EXACT_IN_SINGLE: 28,
+  BIN_SWAP_EXACT_IN: 29,
+  BIN_SWAP_EXACT_OUT_SINGLE: 30,
+  BIN_SWAP_EXACT_OUT: 31
+}, sn = "0x0000000000000000000000000000000000000001", bt = "0x0000000000000000000000000000000000000002", Ge = 0n, Ro = 1n << 255n, Co = "0x0000000000000000000000000000000000000000", Mo = 10n ** 18n, kt = [
+  {
+    type: "function",
+    name: "execute",
+    stateMutability: "payable",
+    inputs: [
+      { name: "commands", type: "bytes" },
+      { name: "inputs", type: "bytes[]" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: []
+  }
+], Fo = [
+  {
+    type: "function",
+    name: "modifyLiquidities",
+    stateMutability: "payable",
+    inputs: [
+      { name: "unlockData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: []
+  }
+], qo = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "decimals",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    type: "function",
+    name: "symbol",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    type: "function",
+    name: "name",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+], Uo = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [
+      { name: "amount", type: "uint160" },
+      { name: "expiration", type: "uint48" },
+      { name: "nonce", type: "uint48" }
+    ]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint160" },
+      { name: "expiration", type: "uint48" }
+    ],
+    outputs: []
+  }
+], Do = (1n << 160n) - 1n, Go = (1n << 48n) - 1n, Wo = (1n << 256n) - 1n;
+class gt {
+  #e = [];
+  /** Appends an action. Order is the execution order. */
+  add(n, t, o) {
+    if (!Number.isInteger(n) || n < 0 || n > 255)
+      throw new RangeError(`action id must fit in one byte: ${n}`);
+    return this.#e.push({ action: n, params: t, label: o }), this;
+  }
+  /** The planned steps, in order. */
+  get steps() {
+    return this.#e;
+  }
+  /** Human-readable trace of the plan, used in dev tooling and error messages. */
+  describe() {
+    return this.#e.map((n, t) => `${t}. ${n.label} (0x${n.action.toString(16).padStart(2, "0")})`).join(`
+`);
+  }
+  /** `abi.encode(bytes actions, bytes[] params)`. */
+  encode() {
+    if (this.#e.length === 0)
+      throw new Error("[@latchprotocol/widgets] cannot encode an empty action plan");
+    const n = Tn(
+      this.#e.map((o) => `0x${o.action.toString(16).padStart(2, "0")}`)
+    ), t = this.#e.map((o) => o.params);
+    return P(
+      [
+        { name: "actions", type: "bytes" },
+        { name: "params", type: "bytes[]" }
+      ],
+      [n, t]
+    );
+  }
+}
+function It() {
+  return new gt();
+}
+const vt = [
+  { name: "currency0", type: "address" },
+  { name: "currency1", type: "address" },
+  { name: "hooks", type: "address" },
+  { name: "poolManager", type: "address" },
+  { name: "fee", type: "uint24" },
+  { name: "parameters", type: "bytes32" }
+], Tt = [
+  {
+    name: "params",
+    type: "tuple",
+    components: [
+      { name: "poolKey", type: "tuple", components: vt },
+      { name: "swapDirection", type: "bool" },
+      { name: "amountIn", type: "uint128" },
+      { name: "amountOutMinimum", type: "uint128" },
+      { name: "hookData", type: "bytes" }
+    ]
+  }
+], Et = [
+  { name: "intermediateCurrency", type: "address" },
+  { name: "fee", type: "uint24" },
+  { name: "hooks", type: "address" },
+  { name: "poolManager", type: "address" },
+  { name: "hookData", type: "bytes" },
+  { name: "parameters", type: "bytes32" }
+], At = [
+  {
+    name: "params",
+    type: "tuple",
+    components: [
+      { name: "currencyIn", type: "address" },
+      { name: "path", type: "tuple[]", components: Et },
+      { name: "amountIn", type: "uint128" },
+      { name: "amountOutMinimum", type: "uint128" }
+    ]
+  }
+], We = [
+  { name: "currency", type: "address" },
+  { name: "amount", type: "uint256" }
+], ee = [
+  { name: "currency", type: "address" },
+  { name: "recipient", type: "address" },
+  { name: "amount", type: "uint256" }
+];
+function an(e) {
+  return R(e, "0x0000000000000000000000000000000000000000");
+}
+function Lt(e) {
+  return R(e.poolKey.currency0, e.currencyIn);
+}
+function St(e) {
+  if (e.length === 0)
+    throw new Error("[@latchprotocol/widgets] cannot encode a swap with no hops");
+  for (let n = 1; n < e.length; n += 1) {
+    const t = e[n - 1], o = e[n];
+    if (!(t === void 0 || o === void 0) && !R(t.currencyOut, o.currencyIn))
+      throw new Error(
+        `[@latchprotocol/widgets] route is not contiguous: hop ${n - 1} outputs ${t.currencyOut} but hop ${n} takes ${o.currencyIn}`
+      );
+  }
+}
+function $t(e) {
+  const n = e[0];
+  if (n === void 0)
+    throw new Error("[@latchprotocol/widgets] cannot encode a swap with no hops");
+  for (const t of e)
+    if (t.poolType !== n.poolType)
+      throw new Error(
+        "[@latchprotocol/widgets] a single swap action cannot mix CL and BIN hops. Split the route into one action per pool type, or route through a single type."
+      );
+  return n.poolType;
+}
+function Bt(e, n, t) {
+  return P(Tt, [
+    {
+      poolKey: {
+        currency0: e.poolKey.currency0,
+        currency1: e.poolKey.currency1,
+        hooks: e.poolKey.hooks,
+        poolManager: e.poolKey.poolManager,
+        fee: e.poolKey.fee,
+        parameters: e.poolKey.parameters
+      },
+      // CL calls this `zeroForOne`, BIN calls it `swapForY`; same bit, same meaning.
+      swapDirection: Lt(e),
+      amountIn: n,
+      amountOutMinimum: t,
+      hookData: e.hookData ?? "0x"
+    }
+  ]);
+}
+function Pt(e, n, t) {
+  const o = e[0];
+  if (o === void 0) throw new Error("[@latchprotocol/widgets] empty route");
+  return P(At, [
+    {
+      currencyIn: o.currencyIn,
+      path: e.map((r) => ({
+        intermediateCurrency: r.currencyOut,
+        fee: r.poolKey.fee,
+        hooks: r.poolKey.hooks,
+        poolManager: r.poolKey.poolManager,
+        hookData: r.hookData ?? "0x",
+        parameters: r.poolKey.parameters
+      })),
+      amountIn: n,
+      amountOutMinimum: t
+    }
+  ]);
+}
+function Nt(e) {
+  St(e.hops);
+  const n = $t(e.hops), t = e.hops[0], o = e.hops[e.hops.length - 1];
+  if (t === void 0 || o === void 0)
+    throw new Error("[@latchprotocol/widgets] empty route");
+  const r = t.currencyIn, s = o.currencyOut;
+  Ot(e);
+  const i = e.hops.length === 1, u = i ? n === "CL" ? O.CL_SWAP_EXACT_IN_SINGLE : O.BIN_SWAP_EXACT_IN_SINGLE : n === "CL" ? O.CL_SWAP_EXACT_IN : O.BIN_SWAP_EXACT_IN, a = i ? Bt(t, e.amountIn, e.minAmountOutGross) : Pt(e.hops, e.amountIn, e.minAmountOutGross), l = It().add(
+    u,
+    a,
+    `${n} swap exact-in${i ? " (single hop)" : ` (${e.hops.length} hops)`}`
+  );
+  l.add(
+    O.SETTLE_ALL,
+    P(We, [r, e.amountIn]),
+    "settle input currency from the caller"
+  );
+  const c = R(e.recipient, e.sender), d = c ? sn : e.recipient;
+  return e.integrator.feeMode === "pay-portion" ? (l.add(
+    O.TAKE,
+    P(ee, [
+      s,
+      bt,
+      Ge
+    ]),
+    "take output to the router for the fee split"
+  ), { plan: l, currencyIn: r, currencyOut: s }) : (e.integrator.active && l.add(
+    O.TAKE_PORTION,
+    P(ee, [
+      s,
+      e.integrator.referrer,
+      BigInt(e.integrator.feeBps)
+    ]),
+    `integrator fee: ${e.integrator.feeBps} bps of output to ${e.integrator.referrer}`
+  ), c ? l.add(
+    O.TAKE_ALL,
+    P(We, [s, e.minAmountOutNet]),
+    "take remaining output to the caller, floored at minAmountOutNet"
+  ) : l.add(
+    O.TAKE,
+    P(ee, [
+      s,
+      d,
+      Ge
+    ]),
+    "take remaining output to the configured recipient"
+  ), { plan: l, currencyIn: r, currencyOut: s });
+}
+function Ot(e) {
+  const { integrator: n } = e;
+  if (n.active) {
+    if (n.feeBps <= 0 || n.feeBps > J)
+      throw new RangeError(
+        `[@latchprotocol/widgets] refusing to encode integrator feeBps ${n.feeBps}; expected 1..${J}. This config should have been rejected by validateIntegratorConfig - do not construct ResolvedIntegratorConfig by hand.`
+      );
+    if (an(n.referrer))
+      throw new Error(
+        "[@latchprotocol/widgets] refusing to encode an integrator fee to the zero address"
+      );
+  }
+  if (e.minAmountOutNet > e.minAmountOutGross)
+    throw new RangeError(
+      `[@latchprotocol/widgets] minAmountOutNet (${e.minAmountOutNet}) exceeds minAmountOutGross (${e.minAmountOutGross}); the fee step can only reduce the output`
+    );
+  if (e.amountIn <= 0n)
+    throw new RangeError(`[@latchprotocol/widgets] amountIn must be positive: ${e.amountIn}`);
+}
+function xt(e) {
+  const { plan: n, currencyIn: t, currencyOut: o } = Nt(e), r = [we.INFI_SWAP], s = [n.encode()], i = e.integrator.feeMode === "pay-portion", a = R(e.recipient, e.sender) ? sn : e.recipient;
+  i && (e.integrator.active && (r.push(we.PAY_PORTION), s.push(
+    P(ee, [
+      o,
+      e.integrator.referrer,
+      BigInt(e.integrator.feeBps)
+    ])
+  )), r.push(we.SWEEP), s.push(
+    P(ee, [
+      o,
+      a,
+      e.minAmountOutNet
+    ])
+  ));
+  const l = `0x${r.map((p) => p.toString(16).padStart(2, "0")).join("")}`, c = En({
+    abi: kt,
+    functionName: "execute",
+    args: [l, s, e.deadline]
+  }), d = e.integrator.active ? Re(
+    e.expectedAmountOutGross ?? e.minAmountOutGross,
+    e.integrator.feeBps
+  ) : 0n;
+  return {
+    to: e.router,
+    data: c,
+    value: an(t) ? e.amountIn : 0n,
+    commands: l,
+    inputs: s,
+    planTrace: n.describe(),
+    integratorFee: e.integrator.active ? {
+      referrer: e.integrator.referrer,
+      feeBps: e.integrator.feeBps,
+      currency: o,
+      mode: e.integrator.feeMode,
+      expectedAmount: d
+    } : null
+  };
+}
+function Ko(e) {
+  return e === "timestamp" ? en : $n;
+}
+const Ho = 1e6, un = "0x0000000000000000000000000000000000000000";
+function Xo(e, n) {
+  const t = n === "timestamp" ? e.startTime : e.startBlock, o = n === "timestamp" ? e.decaySeconds : e.decayBlocks;
+  if (t === void 0 || o === void 0)
+    throw new Error(
+      `[@latchprotocol/widgets] getLaunch result has no ${n === "timestamp" ? "startTime/decaySeconds" : "startBlock/decayBlocks"}: it was decoded with the other hook generation's ABI.`
+    );
+  return {
+    durationClock: n,
+    owner: e.owner,
+    start: BigInt(t),
+    window: Number(o),
+    enabled: e.enabled,
+    initialFeePips: e.initialFeeBips,
+    finalFeePips: e.finalFeeBips,
+    maxBuyPerTx: e.maxBuyPerTx,
+    launchTokenIsCurrency0: e.launchTokenIsCurrency0,
+    launched: e.launched
+  };
+}
+function ln(e) {
+  return !R(e.owner, un);
+}
+function _t(e, n) {
+  if (!ln(e)) return null;
+  if (!e.enabled) return e.finalFeePips;
+  if (n < e.start) return e.initialFeePips;
+  const t = BigInt(e.window), o = n - e.start;
+  if (t <= 0n || o >= t) return e.finalFeePips;
+  const s = BigInt(e.initialFeePips - e.finalFeePips) * o / t;
+  return e.initialFeePips - Number(s);
+}
+function cn(e, n) {
+  const t = e.durationClock;
+  if (!ln(e))
+    return {
+      phase: "unclaimed",
+      durationClock: t,
+      now: n,
+      start: null,
+      end: null,
+      untilOpen: null,
+      remaining: null,
+      decayProgressBps: null,
+      feePips: null,
+      initialFeePips: null,
+      finalFeePips: null,
+      tradingOpen: !1,
+      maxBuyPerTx: null,
+      maxBuyPerTxEnforced: !1
+    };
+  const o = BigInt(e.window), r = e.start + o, s = _t(e, n), i = e.maxBuyPerTx === 0n ? null : e.maxBuyPerTx;
+  if (!e.enabled)
+    return {
+      phase: "disabled",
+      durationClock: t,
+      now: n,
+      start: e.start,
+      end: r,
+      untilOpen: null,
+      remaining: null,
+      decayProgressBps: null,
+      feePips: s,
+      initialFeePips: e.initialFeePips,
+      finalFeePips: e.finalFeePips,
+      tradingOpen: !0,
+      maxBuyPerTx: i,
+      maxBuyPerTxEnforced: !1
+    };
+  if (n < e.start)
+    return {
+      phase: "pending",
+      durationClock: t,
+      now: n,
+      start: e.start,
+      end: r,
+      untilOpen: e.start - n,
+      remaining: null,
+      decayProgressBps: 0,
+      feePips: s,
+      initialFeePips: e.initialFeePips,
+      finalFeePips: e.finalFeePips,
+      tradingOpen: !1,
+      maxBuyPerTx: i,
+      maxBuyPerTxEnforced: !1
+    };
+  const u = n - e.start;
+  return o > 0n && u < o ? {
+    phase: "decaying",
+    durationClock: t,
+    now: n,
+    start: e.start,
+    end: r,
+    untilOpen: null,
+    remaining: o - u,
+    decayProgressBps: Number(u * 10000n / o),
+    feePips: s,
+    initialFeePips: e.initialFeePips,
+    finalFeePips: e.finalFeePips,
+    tradingOpen: !0,
+    maxBuyPerTx: i,
+    maxBuyPerTxEnforced: i !== null
+  } : {
+    phase: "settled",
+    durationClock: t,
+    now: n,
+    start: e.start,
+    end: r,
+    untilOpen: null,
+    remaining: null,
+    decayProgressBps: 1e4,
+    feePips: s,
+    initialFeePips: e.initialFeePips,
+    finalFeePips: e.finalFeePips,
+    tradingOpen: !0,
+    maxBuyPerTx: i,
+    maxBuyPerTxEnforced: !1
+  };
+}
+function dn(e) {
+  const n = cn(e.guard, e.now);
+  return n.phase === "unclaimed" ? {
+    reason: "not-configured",
+    message: "No launch is configured for this pool",
+    revert: "LaunchNotConfigured"
+  } : n.tradingOpen ? n.maxBuyPerTxEnforced && n.maxBuyPerTx !== null && e.amountIn !== null && e.amountIn > n.maxBuyPerTx ? {
+    reason: "exceeds-max-buy-per-tx",
+    message: "Amount is over the per-transaction cap for this launch",
+    revert: "BuyExceedsMaxPerTx"
+  } : { reason: null, message: null, revert: null } : {
+    reason: "trading-not-open",
+    message: "Trading has not opened yet",
+    revert: "TradingNotOpen"
+  };
+}
+function Rt(e, n) {
+  const t = R(e.poolKey.currency0, e.currencyIn);
+  return n.launchTokenIsCurrency0 ? !t : t;
+}
+function Vo(e) {
+  if (R(e.hop.poolKey.hooks, un))
+    throw new Error(
+      "[@latchprotocol/widgets] the pool key names no hook, so it is not a launch pool"
+    );
+  if (!Rt(e.hop, e.guard))
+    throw new Error(
+      "[@latchprotocol/widgets] this hop sells the launch token rather than buying it. Sells are ordinary swaps: use buildSwapCall directly."
+    );
+  const n = dn({
+    guard: e.guard,
+    now: e.now,
+    amountIn: e.amountIn
+  });
+  if (n.reason !== null)
+    throw new Error(
+      `[@latchprotocol/widgets] refusing to encode a launch buy: ${n.message} (the hook would revert ${n.revert})`
+    );
+  const { hop: t, guard: o, now: r, ...s } = e;
+  return xt({ ...s, hops: [t] });
+}
+function Ct(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function A(e, n, t = {}) {
+  const { enabled: o = !0, refetchIntervalMs: r = 0 } = t, [s, i] = I("idle"), [u, a] = I(null), [l, c] = I(null), [d, p] = I(null), [f, k] = I(!1), [v, h] = I(0), m = fe(!0), T = fe(0), C = fe(e);
+  C.current = e, z(() => (m.current = !0, () => {
+    m.current = !1;
+  }), []);
+  const b = y(() => {
+    h((L) => L + 1);
+  }, []);
+  return z(() => {
+    if (!o) {
+      i("idle"), k(!1);
+      return;
+    }
+    T.current += 1;
+    const L = T.current;
+    u !== null ? k(!0) : i("loading"), C.current().then((S) => {
+      !m.current || L !== T.current || (a(S), c(null), i("success"), p(Date.now()), k(!1));
+    }).catch((S) => {
+      !m.current || L !== T.current || (c(Ct(S)), i("error"), k(!1));
+    });
+  }, [o, v, ...n]), z(() => {
+    if (!o || r <= 0) return;
+    const L = setInterval(b, r);
+    return () => clearInterval(L);
+  }, [o, r, b]), { status: s, data: u, error: l, updatedAt: d, isRefreshing: f, refetch: b };
+}
+class Mt extends Error {
+  operation;
+  constructor(n, t) {
+    super(`[@latchprotocol/widgets] ${n} is not available: ${t}`), this.name = "UnsupportedOperationError", this.operation = n;
+  }
+}
+class ue extends Error {
+  constructor(n) {
+    super(`[@latchprotocol/widgets] connect a wallet before attempting to ${n}`), this.name = "WalletNotConnectedError";
+  }
+}
+class Ft extends Error {
+  tokenIn;
+  tokenOut;
+  constructor(n, t) {
+    super(`[@latchprotocol/widgets] no pool connects ${n} to ${t}`), this.name = "NoRouteError", this.tokenIn = n, this.tokenOut = t;
+  }
+}
+const qt = Ln([
+  "error WrappedError(address target, bytes4 selector, bytes reason, bytes details)",
+  "error UnexpectedRevertBytes(bytes revertData)",
+  "error PoolNotInitialized()",
+  "error InvalidFeeForExactOut()",
+  "error InvalidSqrtPriceLimit(uint160 sqrtPriceCurrentX96, uint160 sqrtPriceLimitX96)",
+  "error NoLiquidityToReceiveFees()",
+  "error BinPool__OutOfLiquidity()",
+  "error BinPool__InsufficientAmountUnSpecified()",
+  "error CurrencyNotSettled()",
+  "error HookDeltaExceedsSwapAmount()",
+  "error InvalidHookResponse()",
+  "error HookCallFailed()",
+  "error Error(string)"
+]), Ut = (() => {
+  const e = /* @__PURE__ */ new Set(), n = [];
+  for (const t of [
+    qt,
+    Bn,
+    Pn,
+    Nn,
+    On,
+    xn,
+    en,
+    _n,
+    Un,
+    Dn
+  ])
+    for (const o of t) {
+      if (o.type !== "error" || o.name === void 0) continue;
+      const r = `${o.name}(${(o.inputs ?? []).map((s) => s.type).join(",")})`;
+      e.has(r) || (e.add(r), n.push(o));
+    }
+  return n;
+})(), Dt = {
+  TransactionDeadlinePassed: "The transaction's deadline passed before it was mined. Nothing was spent; try again.",
+  DeadlinePassed: "The transaction's deadline passed before it was mined. Nothing was spent; try again.",
+  SignatureDeadlineExpired: "The signature's deadline passed. Sign again.",
+  TooLittleReceived: "The price moved past your slippage tolerance, so the trade was refused.",
+  V3TooLittleReceived: "The price moved past your slippage tolerance, so the trade was refused.",
+  V2TooLittleReceived: "The price moved past your slippage tolerance, so the trade was refused.",
+  TooMuchRequested: "The price moved past your slippage tolerance, so the trade was refused.",
+  MinimumAmountInsufficient: "The pool would return less than your minimum, so it was refused. Widen slippage or try again.",
+  MaximumAmountExceeded: "The pool would take more than your maximum, so it was refused. Widen slippage or try again.",
+  LiquiditySlippageCaught: "The pool price moved while you were adding liquidity, so it was refused.",
+  IdSlippageCaught: "The active bin moved while you were adding liquidity, so it was refused.",
+  NotEnoughLiquidity: "The pool does not hold enough liquidity to fill this amount.",
+  BinPool__OutOfLiquidity: "The pool does not hold enough liquidity to fill this amount.",
+  InvalidSqrtPriceLimit: "This amount would move the price past the pool's limit. Try a smaller amount.",
+  PoolNotInitialized: "This pool has not been initialised yet.",
+  InsufficientBalance: "Your balance is too low for this transaction.",
+  InsufficientETH: "Not enough native currency was sent with this transaction.",
+  InsufficientToken: "Your token balance is too low for this transaction.",
+  BalanceTooLow: "Your balance is too low for this transaction.",
+  TradingNotOpen: "Trading on this launch pool has not opened yet.",
+  BuyExceedsMaxPerTx: "This buy is larger than the launch's per-transaction cap. Try a smaller amount.",
+  ExactOutputBuyBlockedDuringLaunch: "Exact-output buys are blocked while the launch is decaying.",
+  TaxedActiveBinMintBlocked: "Liquidity cannot be added to the active bin while the launch's creator tax is live.",
+  EnforcedPause: "The router is paused.",
+  ContractLocked: "The contract is busy with another call. Try again.",
+  /* LatchPositionLock / LatchTokenLock (the locker widget). */
+  InsufficientFee: "Less than the lock fee was sent. The fee may have risen since it was read; reload and try again.",
+  AlreadyLocked: "This position is already locked.",
+  EmptyPosition: "This position holds no liquidity, so there is nothing to lock.",
+  NotPositionOwner: "The connected wallet does not own this position.",
+  InvalidUnlock: "The unlock date must be in the future and at most 100 years away.",
+  InvalidOwner: "The lock owner is not a valid address.",
+  NotLater: "A lock can only be extended to a later date, never shortened.",
+  NotLockOwner: "Only the lock owner can do this.",
+  NotPendingOwner: "Only the address the lock was offered to can accept it.",
+  NotLocked: "No lock exists for this position.",
+  StillLocked: "The lock has not reached its unlock date yet.",
+  PositionIsLocked: "This position is held by a lock.",
+  InvalidSchedule: "The schedule is invalid: it needs start <= cliff <= end, an end in the future, at most 100 years away.",
+  InvalidBeneficiary: "The beneficiary is not a valid address.",
+  NativeValueMismatch: "The native amount sent does not match the amount plus the fee.",
+  NoSuchLock: "No lock exists with this id.",
+  NotBeneficiary: "Only the beneficiary can claim or move this lock.",
+  NotPendingBeneficiary: "Only the address the lock was offered to can accept it.",
+  NothingToClaim: "Nothing has vested beyond what was already claimed.",
+  ZeroAmount: "Lock an amount above zero.",
+  SafeERC20FailedOperation: "The token transfer failed. Check the balance and the approval."
+};
+function Gt(e) {
+  let n = null;
+  const t = (i) => {
+    if (n !== null || i === null || typeof i != "object") return;
+    const u = i;
+    for (const a of ["raw", "data"]) {
+      const l = u[a];
+      if (typeof l == "string" && /^0x[0-9a-fA-F]{8,}$/.test(l)) {
+        n = l;
+        return;
+      }
+      if (l !== null && typeof l == "object" && typeof l.data == "string") {
+        const c = l.data;
+        if (/^0x[0-9a-fA-F]{8,}$/.test(c)) {
+          n = c;
+          return;
+        }
+      }
+    }
+    t(u.cause);
+  };
+  if (t(e), n !== null) return n;
+  const o = Me(e), r = /custom error (0x[0-9a-fA-F]{8})(?::\s*(?:0x)?([0-9a-fA-F]*))?/.exec(o);
+  if (r !== null) return `${r[1]}${r[2] ?? ""}`;
+  const s = /signature:\s*\n?\s*(0x[0-9a-fA-F]{8,})/.exec(o);
+  return s !== null ? s[1] : null;
+}
+function Me(e) {
+  return e instanceof Je ? `${e.message}` : e instanceof Error ? e.message : String(e);
+}
+function Te(e, n = 0) {
+  if (n > 4 || e.length < 10) return null;
+  try {
+    const t = An({ abi: Ut, data: e }), o = t.args ?? [];
+    if (t.errorName === "WrappedError") {
+      const r = o[2];
+      return typeof r == "string" && r.length >= 10 ? Te(r, n + 1) ?? "WrappedError" : "WrappedError";
+    }
+    if (t.errorName === "UnexpectedRevertBytes") {
+      const r = o[0];
+      return typeof r == "string" && r.length >= 10 ? Te(r, n + 1) : null;
+    }
+    return t.errorName === "Error" && typeof o[0] == "string" ? `Error: ${o[0]}` : t.errorName;
+  } catch {
+    return null;
+  }
+}
+function Wt(e) {
+  return e.startsWith("Error: ") ? `The contract refused: ${e.slice(7)}` : Dt[e] ?? `The contract refused the transaction (${e}).`;
+}
+function Kt(e) {
+  let n = !1;
+  const t = (o, r) => {
+    if (n || r > 6 || o === null || typeof o != "object") return;
+    const s = o;
+    if (s.code === 4001 || s.name === "UserRejectedRequestError") {
+      n = !0;
+      return;
+    }
+    t(s.cause, r + 1);
+  };
+  return t(e, 0), n || /user rejected|user denied|rejected the request/i.test(Me(e));
+}
+function Ke(e) {
+  const t = e.replace(/^\[@latchprotocol\/widgets\]\s*/, "").split(`
+`)[0]?.trim() ?? "";
+  return t.length > 180 ? `${t.slice(0, 177)}…` : t;
+}
+function pn(e, n = "transaction") {
+  if (e == null) return "Something went wrong.";
+  if (Kt(e)) return "You rejected the request in your wallet. Nothing was sent.";
+  if (e instanceof ue) return "Connect a wallet first.";
+  if (e instanceof Ft) return "No pool on this site connects these two tokens.";
+  const t = Gt(e), o = t === null ? null : Te(t);
+  if (o !== null) return Wt(o);
+  if (e instanceof Mt) {
+    if (e.operation === "quoteSwap") {
+      if (/every direct pool for this pair failed to quote/.test(e.message))
+        return "No pool could quote this trade. The amount may be more than the pool can fill, or trading may not be open yet.";
+      if (/no configured pool holds both/.test(e.message)) return "No pool on this site connects these two tokens.";
+      if (/no quoter is configured/.test(e.message)) return "This site has no quoter for that pool type, so it will not price the trade.";
+    }
+    return e.operation === "quoteAddLiquidity" ? /mint no liquidity/.test(e.message) ? "These amounts add no liquidity to this range. Enter a larger amount of the token the range holds." : /active bin is/.test(e.message) ? "The active bin moved since the range was set. Reset the range and try again." : /nothing to deposit/.test(e.message) ? "The chosen bins take only the token whose amount is zero. Enter an amount of the other token." : "This position cannot be priced on this pool. Check the range and the amounts." : "This action is not available on this deployment.";
+  }
+  if (t !== null) return `The contract refused the transaction (unrecognised error ${t.slice(0, 10)}).`;
+  if (e instanceof Je && typeof e.shortMessage == "string" && e.shortMessage !== "")
+    return /reverted/i.test(e.shortMessage) ? n === "quote" ? "The pool refused to quote this trade." : "The transaction would revert, so it was not sent." : Ke(e.shortMessage);
+  const r = Ke(Me(e));
+  return r === "" ? "Something went wrong." : r;
+}
+function He(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function Ht(e) {
+  const { adapter: n, chain: t, integrator: o } = E(), { tokenIn: r, tokenOut: s, amountIn: i, quote: u, breakdown: a } = e, [l, c] = I("idle"), [d, p] = I(null), [f, k] = I(null), [v, h] = I(null), [m, T] = I(0), b = A(
+    y(() => n.getAccount(), [n]),
+    [n]
+  ).data, L = y(async () => r === null || i === null || b === null ? [] : n.getApprovalRequirements(r, b, i), [n, r, i, b]), S = A(
+    L,
+    [
+      n,
+      r?.address ?? null,
+      i === null ? null : i.toString(),
+      b,
+      m
+    ],
+    { enabled: r !== null && i !== null && i > 0n && b !== null }
+  ).data ?? [], j = S.length > 0, Fe = r !== null && s !== null && i !== null && i > 0n && u !== null && a !== null && b !== null && !j && (l === "idle" || l === "error" || l === "success"), M = y(async () => {
+    const w = S[0];
+    if (w !== void 0) {
+      p(null), c("approving");
+      try {
+        const g = await n.buildApproval(w), $ = await n.sendTransaction(g);
+        await n.waitForTransaction($), T((ie) => ie + 1), c("idle");
+      } catch (g) {
+        const $ = He(g);
+        p($), c("error"), e.onError?.($);
+      }
+    }
+  }, [n, S, e]), ce = y(async () => {
+    if (!(r === null || s === null || i === null) && !(u === null || a === null)) {
+      if (b === null) {
+        const w = new ue("swap");
+        p(w), c("error"), e.onError?.(w);
+        return;
+      }
+      p(null), k(null), c("building");
+      try {
+        const w = await n.buildSwap({
+          quote: u,
+          tokenIn: r,
+          tokenOut: s,
+          amountIn: i,
+          minAmountOutGross: a.minAmountOutGross,
+          minAmountOutNet: a.minAmountOutNet,
+          // The validated config from context. Never a raw prop.
+          integrator: o,
+          recipient: e.recipient ?? b,
+          deadline: await _e(t, n)
+        });
+        h(w), c("awaiting-signature");
+        const g = await n.sendTransaction(w);
+        if (k(g), c("pending"), (await n.waitForTransaction(g)).status === "reverted")
+          throw new Error(`The swap was mined but reverted (${g}).`);
+        c("success"), e.onSuccess?.(g);
+      } catch (w) {
+        const g = He(w);
+        p(g), c("error"), e.onError?.(g);
+      }
+    }
+  }, [
+    n,
+    b,
+    i,
+    a,
+    t,
+    o,
+    e,
+    u,
+    r,
+    s
+  ]), de = y(() => {
+    c("idle"), p(null), k(null), h(null);
+  }, []), Y = l === "idle" && j ? "needs-approval" : l, se = N(
+    () => Xt(Y, S[0], d, n.isMock),
+    [Y, S, d, n.isMock]
+  );
+  return {
+    step: Y,
+    error: d,
+    txHash: f,
+    approvals: S,
+    needsApproval: j,
+    canExecute: Fe,
+    statusMessage: se,
+    preparedTransaction: v,
+    approve: M,
+    execute: ce,
+    reset: de
+  };
+}
+function Xt(e, n, t, o) {
+  const r = o ? "Simulated (mock adapter): " : "";
+  switch (e) {
+    case "idle":
+      return "";
+    case "needs-approval":
+      return n === void 0 ? "Approval required" : n.kind === "erc20-to-permit2" ? `Approve ${n.token.symbol} for Permit2 before swapping` : `Approve the router to spend ${n.token.symbol} via Permit2`;
+    case "approving":
+      return `${r}Waiting for the approval transaction to confirm`;
+    case "building":
+      return `${r}Preparing the swap transaction`;
+    case "awaiting-signature":
+      return `${r}Confirm the transaction in your wallet`;
+    case "pending":
+      return `${r}Swap submitted, waiting for confirmation`;
+    case "success":
+      return `${r}Swap confirmed`;
+    case "error":
+      return t === null ? "Something went wrong" : pn(t, "swap");
+    default:
+      return "";
+  }
+}
+function Vt(e) {
+  const { adapter: n, integrator: t, defaultSlippageBps: o } = E(), { tokenIn: r, tokenOut: s, amountIn: i } = e, u = e.slippageBps ?? o;
+  if (!Number.isInteger(u) || u < 0 || u > _)
+    throw new RangeError(
+      `[@latchprotocol/widgets] slippageBps must be an integer in [0, ${_}]: ${u}`
+    );
+  const a = (e.enabled ?? !0) && r !== null && s !== null && i !== null && i > 0n && r.address.toLowerCase() !== s.address.toLowerCase(), l = y(async () => {
+    if (r === null || s === null || i === null)
+      throw new Error("useSwapQuote: called without a complete request");
+    return n.quoteSwap({ tokenIn: r, tokenOut: s, amountIn: i, ...e.poolId === void 0 ? {} : { poolId: e.poolId } });
+  }, [n, r, s, i, e.poolId]), c = A(
+    l,
+    [
+      n,
+      r?.address ?? null,
+      s?.address ?? null,
+      i === null ? null : i.toString(),
+      e.poolId ?? null
+    ],
+    {
+      enabled: a,
+      refetchIntervalMs: e.refetchIntervalMs ?? 15e3
+    }
+  ), d = N(() => {
+    const v = c.data;
+    if (v === null || !a || c.status === "error" && !c.isRefreshing || r === null || s === null || i === null || v.amountIn !== i) return null;
+    const h = v.route[0], m = v.route[v.route.length - 1];
+    return h !== void 0 && h.tokenIn.address.toLowerCase() !== r.address.toLowerCase() || m !== void 0 && m.tokenOut.address.toLowerCase() !== s.address.toLowerCase() ? null : v;
+  }, [c.data, c.status, c.isRefreshing, a, r, s, i]), p = a ? d !== null ? "success" : c.isRefreshing || c.status === "success" ? "loading" : c.status : "idle", f = N(() => d === null ? null : ct({
+    amountIn: d.amountIn,
+    grossAmountOut: d.grossAmountOut,
+    spotAmountOut: d.spotAmountOut,
+    lpFeeAmount: d.lpFeeAmount,
+    lpFeePips: d.lpFeePips,
+    ...d.lpFeeUnknown === void 0 ? {} : { lpFeeUnknown: d.lpFeeUnknown },
+    slippageBps: u,
+    integrator: t
+  }), [d, u, t]), k = N(() => f === null || r === null || s === null ? null : dt(
+    f.amountIn,
+    r.decimals,
+    f.netAmountOut,
+    s.decimals
+  ), [f, r, s]);
+  return {
+    status: p,
+    quote: d,
+    breakdown: f,
+    error: p === "error" ? c.error : null,
+    isRefreshing: c.isRefreshing && d !== null,
+    updatedAt: c.updatedAt,
+    isMock: n.isMock,
+    rate: k,
+    slippageBps: u,
+    refetch: c.refetch
+  };
+}
+function jo(e) {
+  const { defaultSlippageBps: n } = E(), [t, o] = I(e ?? n), [r, s] = I(null), i = y((u) => {
+    if (!Number.isInteger(u) || u < 0) {
+      s("Slippage must be a whole number of basis points");
+      return;
+    }
+    if (u > _) {
+      s(`Slippage above ${_ / 100}% is not accepted`);
+      return;
+    }
+    s(null), o(u);
+  }, []);
+  return { slippageBps: t, setSlippageBps: i, error: r };
+}
+function jt(e) {
+  return e instanceof G && e.contract === "launchGuardHook";
+}
+function Yo(e) {
+  return e.status === "error" ? jt(e.error) || Yt(e.error) ? "not-configured" : "error" : e.status === "loading" || e.status === "idle" ? "loading" : e.data === null || Array.isArray(e.data) && e.data.length === 0 ? "empty" : "ready";
+}
+function Zo() {
+  const { adapter: e } = E();
+  return A(
+    y(() => e.listLaunches(), [e]),
+    [e],
+    { refetchIntervalMs: 12e3 }
+  );
+}
+function Yt(e) {
+  return e instanceof G && e.contract === "launchpadKitV2";
+}
+function Qo(e) {
+  const { adapter: n } = E(), t = y(async () => e === null ? [] : n.getLaunchesForToken(e), [n, e]);
+  return A(t, [n, e], { enabled: e !== null, refetchIntervalMs: 12e3 });
+}
+function zo(e) {
+  const { adapter: n } = E(), t = y(async () => e === null ? null : n.getLaunch(e), [n, e]);
+  return A(t, [n, e], {
+    enabled: e !== null,
+    refetchIntervalMs: 12e3
+  });
+}
+function Jo(e) {
+  const n = cn(e.guard, e.readAt), { initialFeePips: t, finalFeePips: o } = e.guard, r = t - o, s = r <= 0 ? null : Math.max(
+    0,
+    Math.min(1e4, Math.round((t - e.currentFeePips) * 1e4 / r))
+  );
+  return {
+    launch: e,
+    schedule: n,
+    feeSpanProgressBps: s,
+    feeProjectionDriftPips: n.feePips === null ? null : e.currentFeePips - n.feePips
+  };
+}
+function er(e) {
+  const { launch: n, amountIn: t } = e, o = N(() => n === null ? { reason: "not-configured", message: "No launch loaded", revert: null } : dn({
+    guard: n.guard,
+    now: n.readAt,
+    amountIn: t
+  }), [n, t]), r = Vt({
+    tokenIn: n?.quoteToken ?? null,
+    tokenOut: n?.launchToken ?? null,
+    amountIn: t,
+    ...e.slippageBps === void 0 ? {} : { slippageBps: e.slippageBps },
+    /* THIS pool. A v2 token can have a CL and a Bin leg against the same quote;
+       the schedule shown and the pool bought through must be the same one. */
+    ...n === null ? {} : { poolId: n.poolId },
+    enabled: n !== null && o.reason === null
+  }), s = Ht({
+    tokenIn: n?.quoteToken ?? null,
+    tokenOut: n?.launchToken ?? null,
+    amountIn: t,
+    quote: r.quote,
+    breakdown: r.breakdown,
+    ...e.recipient === void 0 ? {} : { recipient: e.recipient },
+    ...e.onSuccess === void 0 ? {} : { onSuccess: e.onSuccess }
+  });
+  return {
+    gate: o,
+    breakdown: r.breakdown,
+    quoteStatus: r.status,
+    quoteError: r.error,
+    quoteIsRefreshing: r.isRefreshing,
+    rate: r.rate,
+    execution: s,
+    canBuy: o.reason === null && s.canExecute && r.status === "success"
+  };
+}
+function nr() {
+  const { adapter: e } = E();
+  return A(y(() => e.listTokens(), [e]), [e]);
+}
+function tr() {
+  const { adapter: e } = E();
+  return A(y(() => e.getAccount(), [e]), [e]);
+}
+function or(e, n) {
+  const { adapter: t } = E(), o = y(async () => e === null || n === null ? 0n : t.getBalance(e, n), [t, e, n]);
+  return A(o, [t, e?.address ?? null, n], {
+    enabled: e !== null && n !== null,
+    refetchIntervalMs: 3e4
+  });
+}
+function rr() {
+  const { adapter: e } = E();
+  return A(y(() => e.listPools(), [e]), [e]);
+}
+function sr(e) {
+  const { adapter: n } = E(), t = y(async () => e === null ? null : n.getPoolState(e), [n, e]);
+  return A(t, [n, e?.id ?? null], { enabled: e !== null });
+}
+const X = 1n << 96n, Ee = 1n << 128n, Zt = (1n << 256n) - 1n, be = 1n << 256n, Ae = -887272, Le = 887272, Qt = [
+  [0x2n, 0xfff97272373d413259a46990580e213an],
+  [0x4n, 0xfff2e50f5f656932ef12357cf3c7fdccn],
+  [0x8n, 0xffe5caca7e10e4e61c3624eaa0941cd0n],
+  [0x10n, 0xffcb9843d60f6159c9db58835c926644n],
+  [0x20n, 0xff973b41fa98c081472e6896dfb254c0n],
+  [0x40n, 0xff2ea16466c96a3843ec78b326b52861n],
+  [0x80n, 0xfe5dee046a99a2a811c461f1969c3053n],
+  [0x100n, 0xfcbe86c7900a88aedcffc83b479aa3a4n],
+  [0x200n, 0xf987a7253ac413176f2b074cf7815e54n],
+  [0x400n, 0xf3392b0822b70005940c7a398e4b70f3n],
+  [0x800n, 0xe7159475a2c29b7443b29c7fa6e889d9n],
+  [0x1000n, 0xd097f3bdfd2022b8845ad8f792aa5825n],
+  [0x2000n, 0xa9f746462d870fdf8a65dc1f90e061e5n],
+  [0x4000n, 0x70d869a156d2a1b890bb3df62baf32f7n],
+  [0x8000n, 0x31be135f97d08fd981231505542fcfa6n],
+  [0x10000n, 0x9aa508b5b7a84e1c677de54f3e99bc9n],
+  [0x20000n, 0x5d6af8dedb81196699c329225ee604n],
+  [0x40000n, 0x2216e584f5fa1ea926041bedfe98n],
+  [0x80000n, 0x48a170391f7dc42444e8fa2n]
+];
+function B(e) {
+  if (!Number.isInteger(e) || e < Ae || e > Le)
+    throw new RangeError(`tick out of range: ${e}`);
+  const n = BigInt(Math.abs(e));
+  let t = (n & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : Ee;
+  for (const [o, r] of Qt)
+    (n & o) !== 0n && (t = t * r >> 128n);
+  return e > 0 && (t = Zt / t), (t >> 32n) + (t % (1n << 32n) === 0n ? 0n : 1n);
+}
+function fn(e, n, t) {
+  const o = e * n;
+  return o % t === 0n ? o / t : o / t + 1n;
+}
+function zt(e, n) {
+  return e % n === 0n ? e / n : e / n + 1n;
+}
+function re(e, n) {
+  return e <= n ? [e, n] : [n, e];
+}
+function Se(e, n, t, o) {
+  const [r, s] = re(e, n), i = t << 96n, u = s - r;
+  return o ? zt(fn(i, u, s), r) : i * u / s / r;
+}
+function $e(e, n, t, o) {
+  const [r, s] = re(e, n);
+  return o ? fn(t, s - r, X) : t * (s - r) / X;
+}
+function Be(e, n, t) {
+  const [o, r] = re(e, n), s = o * r / X;
+  return t * s / (r - o);
+}
+function Pe(e, n, t) {
+  const [o, r] = re(e, n);
+  return t * X / (r - o);
+}
+function ir(e, n, t, o, r) {
+  const [s, i] = re(n, t);
+  if (e <= s) return Be(s, i, o);
+  if (e < i) {
+    const u = Be(e, i, o), a = Pe(s, e, r);
+    return u < a ? u : a;
+  }
+  return Pe(s, i, r);
+}
+function ar(e, n, t, o, r) {
+  const s = B(n), i = B(t);
+  return e <= s ? { amount0: Se(s, i, o, r), amount1: 0n } : e < i ? {
+    amount0: Se(e, i, o, r),
+    amount1: $e(s, e, o, r)
+  } : { amount0: 0n, amount1: $e(s, i, o, r) };
+}
+function Jt(e, n, t) {
+  const o = B(n), r = B(t);
+  return e <= o ? "token0-only" : e >= r ? "token1-only" : "both";
+}
+function ur(e, n, t, o, r) {
+  if (Jt(e, n, t) !== "both") return null;
+  const s = B(n), i = B(t);
+  if (r <= 0n) return 0n;
+  if (o === "token0") {
+    const a = Be(e, i, r);
+    return $e(s, e, a, !0);
+  }
+  const u = Pe(s, e, r);
+  return Se(e, i, u, !0);
+}
+const q = (e) => (e % be + be) % be;
+function lr(e) {
+  const { currentTick: n, tickLower: t, tickUpper: o, lower: r, upper: s } = e, i = e.feeGrowthGlobal0X128, u = e.feeGrowthGlobal1X128, a = n >= t ? r.feeGrowthOutside0X128 : q(i - r.feeGrowthOutside0X128), l = n >= t ? r.feeGrowthOutside1X128 : q(u - r.feeGrowthOutside1X128), c = n < o ? s.feeGrowthOutside0X128 : q(i - s.feeGrowthOutside0X128), d = n < o ? s.feeGrowthOutside1X128 : q(u - s.feeGrowthOutside1X128), p = q(i - a - c), f = q(u - l - d);
+  return {
+    fees0: q(p - e.feeGrowthInside0LastX128) * e.liquidity / Ee,
+    fees1: q(f - e.feeGrowthInside1LastX128) * e.liquidity / Ee
+  };
+}
+function cr() {
+  if (B(0) !== X)
+    throw new Error(`getSqrtRatioAtTick(0) is ${B(0)}, expected 2^96 (${X})`);
+  const e = 1461446703485210103287273052203988822378723970342n;
+  if (B(Le) !== e)
+    throw new Error(
+      `getSqrtRatioAtTick(MAX_TICK) is ${B(Le)}, expected ${e}`
+    );
+  const n = 4295128739n;
+  if (B(Ae) !== n)
+    throw new Error(
+      `getSqrtRatioAtTick(MIN_TICK) is ${B(Ae)}, expected ${n}`
+    );
+}
+function eo(e) {
+  return e.isNative === !0 || R(e.address, W);
+}
+function no(e, n, t) {
+  const o = [], r = (s, i, u) => {
+    const a = eo(s) ? u : i;
+    a > 0n && o.push({ token: s, required: a });
+  };
+  return r(e.pool.token0, e.amount0, n), r(e.pool.token1, e.amount1, t), o;
+}
+function to(e, n) {
+  for (const [t, o] of e.entries()) {
+    const r = n[t] ?? null;
+    if (r !== null && r < o.required) return o.token;
+  }
+  return null;
+}
+class Xe extends Error {
+  token;
+  constructor(n) {
+    super(`Insufficient ${n.symbol}: the wallet holds less than this deposit needs. Nothing was signed.`), this.name = "InsufficientBalanceError", this.token = n;
+  }
+}
+function hn(e) {
+  return e.tickSpacing !== void 0 ? e.tickSpacing : Cn(e.key).tickSpacing;
+}
+function dr(e) {
+  return e.binStep !== void 0 ? e.binStep : Rn(e.key).binStep;
+}
+function pr(e, n) {
+  const t = P(
+    [
+      { name: "poolId", type: "bytes32" },
+      { name: "binId", type: "uint256" }
+    ],
+    [e, BigInt(n)]
+  );
+  return BigInt(Sn(t));
+}
+function fr(e) {
+  return e.totalShares === 0n || e.shares === 0n ? { amount0: 0n, amount1: 0n } : {
+    amount0: e.reserveX * e.shares / e.totalShares,
+    amount1: e.reserveY * e.shares / e.totalShares
+  };
+}
+function hr(e, n, t, o = 10) {
+  if (e.poolType === "CL") {
+    const r = hn(e);
+    if (n === null) return null;
+    const s = r * o;
+    return {
+      type: "CL",
+      tickLower: pt(n - s, r),
+      tickUpper: ft(n + s, r)
+    };
+  }
+  return t === null ? null : {
+    type: "BIN",
+    activeIdDesired: t,
+    binIdLower: t - o,
+    binIdUpper: t + o,
+    idSlippage: 5
+  };
+}
+function mr(e, n, t) {
+  if (e.type === "CL") {
+    const s = hn(n), i = e.tickLower - t * s, u = e.tickUpper + t * s;
+    return i >= u ? e : { type: "CL", tickLower: i, tickUpper: u };
+  }
+  const o = e.binIdLower - t, r = e.binIdUpper + t;
+  return o > r ? e : { ...e, binIdLower: o, binIdUpper: r };
+}
+function yr(e) {
+  if (e.type === "CL")
+    return `Ticks ${e.tickLower} to ${e.tickUpper}`;
+  const n = e.binIdUpper - e.binIdLower + 1;
+  return `Bins ${e.binIdLower} to ${e.binIdUpper} (${n} bins, active ${e.activeIdDesired})`;
+}
+function wr(e) {
+  const { adapter: n } = E(), { pool: t, range: o, amount0Desired: r, amount1Desired: s } = e, i = (e.enabled ?? !0) && t !== null && o !== null && (r ?? 0n) + (s ?? 0n) > 0n, u = y(async () => t === null || o === null ? null : n.quoteAddLiquidity({
+    pool: t,
+    range: o,
+    amount0Desired: r ?? 0n,
+    amount1Desired: s ?? 0n
+  }), [n, t, o, r, s]);
+  return { ...A(
+    u,
+    [
+      n,
+      t?.id ?? null,
+      o === null ? null : JSON.stringify(o),
+      r?.toString() ?? null,
+      s?.toString() ?? null
+    ],
+    { enabled: i }
+  ), isMock: n.isMock };
+}
+function Ne(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function br(e) {
+  const { adapter: n, chain: t, integrator: o, defaultSlippageBps: r } = E(), { quote: s } = e, i = e.slippageBps ?? r, [u, a] = I("idle"), [l, c] = I(null), [d, p] = I(null), [f, k] = I(0), h = A(
+    y(() => n.getAccount(), [n]),
+    [n]
+  ).data, m = N(() => s === null ? null : {
+    amount0Max: De(s.amount0, i),
+    amount1Max: De(s.amount1, i)
+  }, [s, i]), T = N(
+    () => s === null || m === null ? [] : no(s, m.amount0Max, m.amount1Max),
+    [s, m]
+  ), C = T.map((w) => `${w.token.address}:${w.required.toString()}`).join(","), b = y(async () => {
+    if (h === null || T.length === 0) return null;
+    const w = await Promise.all(T.map((g) => n.getBalance(g.token, h)));
+    return to(T, w);
+  }, [n, h, T]), L = A(
+    b,
+    [n, h, C, f],
+    { enabled: h !== null && T.length > 0, refetchIntervalMs: 3e4 }
+  ), V = T.length === 0 || h === null ? null : L.data ?? null, S = L.refetch, j = y(async () => {
+    if (s === null || h === null || m === null) return [];
+    const w = s.pool.poolType === "CL" ? t.contracts.clPositionManager : t.contracts.binPositionManager, [g, $] = await Promise.all([
+      n.getApprovalRequirements(s.pool.token0, h, m.amount0Max, w),
+      n.getApprovalRequirements(s.pool.token1, h, m.amount1Max, w)
+    ]);
+    return [...g, ...$];
+  }, [n, t, s, h, m]), M = A(
+    j,
+    [n, s?.pool.id ?? null, h, m?.amount0Max.toString() ?? null, f],
+    { enabled: s !== null && h !== null }
+  ).data ?? [], ce = y(async () => {
+    const w = M[0];
+    if (w !== void 0) {
+      c(null), a("approving");
+      try {
+        const g = await b();
+        if (g !== null)
+          throw S(), new Xe(g);
+        const $ = await n.buildApproval(w), ie = await n.sendTransaction($);
+        await n.waitForTransaction(ie), k((pe) => pe + 1), a("idle");
+      } catch (g) {
+        c(Ne(g)), a("error");
+      }
+    }
+  }, [n, M, b, S]), de = y(async () => {
+    if (!(s === null || m === null)) {
+      if (h === null) {
+        c(new ue("add liquidity")), a("error");
+        return;
+      }
+      c(null), a("building");
+      try {
+        const w = await b();
+        if (w !== null)
+          throw S(), new Xe(w);
+        const g = await n.buildAddLiquidity({
+          quote: s,
+          amount0Max: m.amount0Max,
+          amount1Max: m.amount1Max,
+          recipient: e.recipient ?? h,
+          deadline: await _e(t, n),
+          integrator: o,
+          ...e.hookData ? { hookData: e.hookData } : {}
+        });
+        a("awaiting-signature");
+        const $ = await n.sendTransaction(g);
+        if (p($), a("pending"), (await n.waitForTransaction($)).status === "reverted") throw new Error(`The transaction was mined but reverted (${$}).`);
+        a("success"), k((pe) => pe + 1), e.onSuccess?.($);
+      } catch (w) {
+        c(Ne(w)), a("error");
+      }
+    }
+  }, [n, h, m, t, o, e, s, b, S]), Y = y(() => {
+    a("idle"), c(null), p(null);
+  }, []), se = u === "idle" && M.length > 0 && V === null ? "needs-approval" : u;
+  return {
+    step: se,
+    error: l,
+    txHash: d,
+    approvals: M,
+    needsApproval: M.length > 0,
+    insufficient: V,
+    statusMessage: mn(se, M[0], l, n.isMock),
+    approve: ce,
+    execute: de,
+    reset: Y
+  };
+}
+function kr(e, n, t = 0) {
+  const { adapter: o } = E(), r = y(async () => e === null ? [] : n == null ? o.listPositions(e) : o.listPositions(e, n), [o, e, n]);
+  return A(r, [o, e, n?.id ?? null, t], {
+    enabled: e !== null
+  });
+}
+function gr(e) {
+  const { adapter: n, chain: t, integrator: o, defaultSlippageBps: r } = E(), { position: s, percentBps: i } = e, u = e.slippageBps ?? r, [a, l] = I("idle"), [c, d] = I(null), [p, f] = I(null), k = y(async () => s === null ? null : n.quoteRemoveLiquidity(s, i), [n, s, i]), v = A(
+    k,
+    /* Keyed on the position RECORD, not its id: after a partial removal the
+       re-read list hands over a new record with less liquidity, and the quote
+       must follow it rather than keep pricing the old one. */
+    [n, s, i],
+    { enabled: s !== null && i > 0 }
+  ), h = y(async () => {
+    const T = v.data;
+    if (s === null || T === null) return;
+    const C = await n.getAccount();
+    if (C === null) {
+      d(new ue("remove liquidity")), l("error");
+      return;
+    }
+    d(null), l("building");
+    try {
+      const b = await n.buildRemoveLiquidity({
+        position: s,
+        percentBps: i,
+        amount0Min: ve(T.amount0, u),
+        amount1Min: ve(T.amount1, u),
+        recipient: e.recipient ?? C,
+        deadline: await _e(t, n),
+        integrator: o
+      });
+      l("awaiting-signature");
+      const L = await n.sendTransaction(b);
+      if (f(L), l("pending"), (await n.waitForTransaction(L)).status === "reverted") throw new Error(`The transaction was mined but reverted (${L}).`);
+      l("success"), e.onSuccess?.(L);
+    } catch (b) {
+      d(Ne(b)), l("error");
+    }
+  }, [n, t, o, e, i, s, v.data, u]), m = y(() => {
+    l("idle"), d(null), f(null);
+  }, []);
+  return {
+    quote: v.data,
+    quoteStatus: v.status,
+    step: a,
+    error: c,
+    txHash: p,
+    statusMessage: mn(a, void 0, c, n.isMock),
+    execute: h,
+    reset: m
+  };
+}
+function mn(e, n, t, o) {
+  const r = o ? "Simulated (mock adapter): " : "";
+  switch (e) {
+    case "idle":
+      return "";
+    case "needs-approval":
+      return n === void 0 ? "Approval required" : `Approve ${n.token.symbol} before continuing`;
+    case "approving":
+      return `${r}Waiting for the approval to confirm`;
+    case "building":
+      return `${r}Preparing the transaction`;
+    case "awaiting-signature":
+      return `${r}Confirm the transaction in your wallet`;
+    case "pending":
+      return `${r}Submitted, waiting for confirmation`;
+    case "success":
+      return `${r}Confirmed`;
+    case "error":
+      return t === null ? "Something went wrong" : pn(t, "liquidity");
+    default:
+      return "";
+  }
+}
+function Ir(e, n) {
+  return (t) => {
+    e(), n?.(t);
+  };
+}
+function vr(e) {
+  return e.filter((n) => n.liquidity > 0n || n.feesOwed0 > 0n || n.feesOwed1 > 0n);
+}
+function Tr(e, n) {
+  if (e !== null) {
+    const t = n.find((o) => o.id === e.id);
+    if (t !== void 0) return t;
+  }
+  return n[0] ?? null;
+}
+function yn(e) {
+  return typeof e.url == "string";
+}
+const oo = "0x0000000000000000000000000000000000000000";
+function wn(e) {
+  const n = [];
+  for (const t of e.tokens) {
+    if (!xe(t.address)) continue;
+    const o = Fn(t), r = {
+      address: t.address,
+      symbol: t.symbol,
+      name: t.name,
+      decimals: t.decimals,
+      ...t.logoURI === void 0 ? {} : { logoUrl: t.logoURI },
+      ...t.address.toLowerCase() === oo ? { isNative: !0 } : {},
+      listSource: { name: t.source.name, alsoIn: t.alsoIn.map((s) => s.name) },
+      ...o === null ? {} : { stock: o },
+      ...t.tags === void 0 ? {} : { tags: t.tags }
+    };
+    n.push(r);
+  }
+  return n;
+}
+function Er(e, n) {
+  const t = /* @__PURE__ */ new Map();
+  for (const o of e) t.set(o.address.toLowerCase(), o);
+  for (const o of n) {
+    const r = o.address.toLowerCase(), s = t.get(r);
+    if (s === void 0) {
+      t.set(r, o);
+      continue;
+    }
+    t.set(r, {
+      ...s,
+      ...s.logoUrl === void 0 && o.logoUrl !== void 0 ? { logoUrl: o.logoUrl } : {},
+      /* The adapter's token stays the adapter's; the lists that also name it are recorded as corroboration. */
+      ...o.listSource !== void 0 ? { listSource: { name: s.listSource?.name ?? null, alsoIn: [...s.listSource?.alsoIn ?? [], o.listSource.name ?? "", ...o.listSource.alsoIn].filter((i) => i !== "") } } : {},
+      ...s.stock === void 0 && o.stock !== void 0 ? { stock: o.stock } : {},
+      ...s.tags === void 0 && o.tags !== void 0 ? { tags: o.tags } : {}
+    });
+  }
+  return [...t.values()];
+}
+function Ar(e, n) {
+  return wn(nn(e, { chainId: n }));
+}
+function Lr(e, n) {
+  if (e === void 0) return null;
+  if (e.startsWith("https://")) return e;
+  if (e.startsWith("ipfs://")) {
+    const t = Mn(e, n === void 0 ? {} : { gateways: n });
+    return t === null || t.length === 0 ? null : t[0] ?? null;
+  }
+  return null;
+}
+function Sr(e) {
+  const n = /* @__PURE__ */ new Map();
+  n.set(null, []);
+  for (const t of e) {
+    const o = t.listSource?.name ?? null, r = n.get(o);
+    r === void 0 ? n.set(o, [t]) : r.push(t);
+  }
+  return [...n.entries()].filter(([, t]) => t.length > 0).map(([t, o]) => ({ source: t, tokens: o }));
+}
+const Z = { tokens: [], status: "idle", failures: [], sources: [] };
+function ro(e) {
+  return e === void 0 ? "" : e.map((n) => yn(n) ? `url:${n.url}` : `list:${n.name}@${n.version.major}.${n.version.minor}.${n.version.patch}:${n.tokens.length}`).join("|");
+}
+function $r(e) {
+  const { chain: n } = E(), t = ro(e), [o, r] = I({ key: "", resource: Z });
+  return z(() => {
+    if (e === void 0 || e.length === 0) {
+      r({ key: t, resource: Z });
+      return;
+    }
+    let s = !1;
+    return r((i) => i.key === t ? i : { key: t, resource: { ...Z, status: "loading" } }), Promise.all(
+      e.map(async (i) => {
+        if (!yn(i)) return i;
+        try {
+          return (await qn(i.url)).list;
+        } catch (u) {
+          return { url: i.url, message: u instanceof Error ? u.message : String(u) };
+        }
+      })
+    ).then((i) => {
+      if (s) return;
+      const u = i.filter((c) => !("url" in c && "message" in c)), a = i.filter((c) => "url" in c && "message" in c), l = nn(u, { chainId: n.chainId });
+      r({ key: t, resource: { tokens: wn(l), status: "ready", failures: a, sources: u.map((c) => c.name) } });
+    }), () => {
+      s = !0;
+    };
+  }, [t, n.chainId]), N(() => o.key === t ? o.resource : e === void 0 || e.length === 0 ? Z : { ...Z, status: "loading" }, [o, t, e]);
+}
+function bn(e) {
+  return "token" in e ? { token: e.token, quote: e.quote } : { token: e.tokenOut, quote: e.tokenIn };
+}
+function Ve(e) {
+  return (typeof e == "string" ? e : e.address).toLowerCase();
+}
+function Br(e) {
+  if (e === void 0) return null;
+  const n = bn(e);
+  return `${Ve(n.token)}:${Ve(n.quote)}`;
+}
+function Oe(e, n) {
+  if (n === void 0) return null;
+  const t = n.toLowerCase();
+  return e.find((o) => o.address.toLowerCase() === t) ?? null;
+}
+function Pr(e, n) {
+  return typeof e != "string" ? e : Oe(n, e);
+}
+function ke(e, n) {
+  return n === "buy" ? { tokenIn: e.quote, tokenOut: e.token } : { tokenIn: e.token, tokenOut: e.quote };
+}
+function ge(e, n) {
+  return n === "buy" ? { token: e.tokenOut, quote: e.tokenIn } : { token: e.tokenIn, quote: e.tokenOut };
+}
+function Nr(e) {
+  return e === "buy" ? "sell" : "buy";
+}
+const so = [0.25, 0.5, 0.75, 1], je = 10n ** 15n;
+function Or(e) {
+  if (e === void 0) return so;
+  for (const n of e)
+    if (typeof n != "number" || !Number.isFinite(n) || n <= 0 || n > 1)
+      throw new RangeError(`[@latchprotocol/widgets] portions must be fractions in (0, 1]: ${String(n)}`);
+  return e;
+}
+function xr(e) {
+  if (e === 1) return "Max";
+  const n = e * 100;
+  return `${Number.isInteger(n) ? n : Number(n.toFixed(2))}%`;
+}
+function io(e, n, t) {
+  const o = BigInt(Math.round(n * 1e4)), r = e * o / 10000n;
+  return t.isNative === !0 && n === 1 ? r > je ? r - je : 0n : r;
+}
+function _r(e, n, t) {
+  return e === null || n === null ? null : ze(io(n, t, e), e.decimals);
+}
+const Ye = {
+  anchor: { token: null, quote: null },
+  side: "buy",
+  amountText: "",
+  impactAck: !1
+};
+function Rr(e) {
+  const n = e.side ?? "buy";
+  if (e.pair === void 0) return { ...Ye, side: n };
+  const t = bn(e.pair);
+  return {
+    ...Ye,
+    side: n,
+    anchor: {
+      token: typeof t.token == "string" ? null : t.token,
+      quote: typeof t.quote == "string" ? null : t.quote
+    }
+  };
+}
+function Cr(e, n) {
+  switch (n.type) {
+    case "seed": {
+      if (n.tokens.length === 0) return e;
+      const t = ke(e.anchor, n.side), o = t.tokenIn ?? Oe(n.tokens, n.defaultTokenIn) ?? n.tokens[0] ?? null, r = t.tokenOut ?? Oe(n.tokens, n.defaultTokenOut) ?? n.tokens[1] ?? null;
+      return o === t.tokenIn && r === t.tokenOut ? e : { ...e, anchor: ge({ tokenIn: o, tokenOut: r }, n.side) };
+    }
+    case "pin":
+      return n.anchor.token === e.anchor.token && n.anchor.quote === e.anchor.quote ? e : { ...e, anchor: n.anchor, impactAck: !1 };
+    case "select-in": {
+      const t = ke(e.anchor, n.side);
+      return { ...e, anchor: ge({ tokenIn: n.token, tokenOut: t.tokenOut }, n.side), impactAck: !1 };
+    }
+    case "select-out": {
+      const t = ke(e.anchor, n.side);
+      return { ...e, anchor: ge({ tokenIn: t.tokenIn, tokenOut: n.token }, n.side), impactAck: !1 };
+    }
+    case "set-side":
+      return n.side === e.side ? e : { ...e, side: n.side, impactAck: !1, ...n.amountText === void 0 ? {} : { amountText: n.amountText } };
+    case "amount":
+      return n.text === e.amountText ? e : { ...e, amountText: n.text, impactAck: !1 };
+    case "ack":
+      return e.impactAck === n.value ? e : { ...e, impactAck: n.value };
+    default:
+      return e;
+  }
+}
+function ao(e) {
+  if (e.length === 0) return [];
+  const n = [e[0]?.tokenIn.symbol ?? ""];
+  for (const t of e) n.push(t.tokenOut.symbol);
+  return n.filter((t) => t !== "");
+}
+function Mr(e) {
+  const { tokenIn: n, tokenOut: t, quote: o, breakdown: r } = e;
+  return n === null || t === null || o === null || r === null ? null : {
+    tokenIn: n,
+    tokenOut: t,
+    amountIn: r.amountIn,
+    amountOut: r.netAmountOut,
+    grossAmountOut: r.grossAmountOut,
+    minReceived: r.minAmountOutNet,
+    integratorFee: r.integratorFee,
+    slippageBps: r.slippageBps,
+    priceImpactBps: r.priceImpactBps,
+    priceImpactSeverity: r.priceImpactSeverity,
+    lpFee: {
+      pips: r.lpFeePips,
+      unknown: r.lpFeeUnknown,
+      label: r.lpFeeUnknown ? "dynamic (hook-set)" : mt(r.lpFeePips)
+    },
+    route: o.route,
+    routeSymbols: ao(o.route),
+    rate: e.rate,
+    status: e.status,
+    isRefreshing: e.isRefreshing,
+    isMock: e.isMock,
+    updatedAt: e.updatedAt
+  };
+}
+const kn = { symbol: "ETH", decimals: 18 };
+async function Q(e, n, t) {
+  if (n.toLowerCase() === W) return { address: W, symbol: t.symbol, decimals: t.decimals };
+  const [o, r] = await Promise.all([
+    e.readContract({ address: n, abi: qe, functionName: "symbol" }).catch(() => null),
+    e.readContract({ address: n, abi: qe, functionName: "decimals" }).catch(() => null)
+  ]);
+  return { address: n, symbol: o ?? wt(n), decimals: r === null ? null : Number(r) };
+}
+async function gn(e, n, t) {
+  if (!n.lpLocker) return [];
+  if (n.lpLockerTokenIds) return n.lpLockerTokenIds;
+  if (n.lpLockerFromBlock === void 0) return [];
+  const o = await e.getBlockNumber();
+  return (await tn(e, n.lpLocker, { fromBlock: n.lpLockerFromBlock, toBlock: o }, t)).map((r) => r.tokenId);
+}
+async function Fr(e, n, t, o = {}) {
+  const r = o.native ?? kn, s = o.lp ?? {};
+  if (s.poolType === "bin") {
+    const [p, f] = await Promise.all([Gn(e, s.binLpLocker, t), Ie(e)]), k = Date.now(), v = p.locks[0], [h, m] = await Promise.all([Q(e, v?.currency0 ?? W, r), Q(e, v?.currency1 ?? W, r)]);
+    return { summary: Ue({ poolId: t, currency0: h.address, currency1: m.address, pool: null, locks: [] }), bin: p, currency0: h, currency1: m, chainNow: f, readAtMs: k };
+  }
+  const i = await gn(e, s, t);
+  let u, a;
+  if (n !== null) {
+    const p = await Wn(e, n, t, { lpLocker: s.lpLocker ?? null, lpLockerTokenIds: i });
+    u = p, a = p.now;
+  } else {
+    const [p, f] = await Promise.all([Kn(e, s.lpLocker, t, { tokenIds: i }), Ie(e)]), k = p.permanent[0];
+    u = Ue({ poolId: t, currency0: k?.currency0 ?? W, currency1: k?.currency1 ?? W, pool: p.pool, locks: [], permanent: p.permanent }), a = f;
+  }
+  const l = Date.now(), [c, d] = await Promise.all([Q(e, u.currency0, r), Q(e, u.currency1, r)]);
+  return { summary: u, bin: null, currency0: c, currency1: d, chainNow: a, readAtMs: l };
+}
+function qr(e, n = {}) {
+  return n.poolType === "bin" ? !!n.binLpLocker : e !== null || !!n.lpLocker;
+}
+async function Ur(e, n, t, o = {}) {
+  const r = o.native ?? kn, s = o.lp ?? {}, i = !!s.lpLocker || !!s.binLpLocker, [u, a, l, c] = await Promise.all([
+    n === null ? Promise.resolve(null) : Hn(e, n, t),
+    Q(e, t, r),
+    Ie(e),
+    i ? (async () => {
+      const d = await gn(e, s), [p, f] = await Promise.all([
+        s.lpLocker ? Xn(e, s.lpLocker, d) : Promise.resolve([]),
+        s.binLpLocker ? Vn(e, s.binLpLocker).then((k) => k.locks) : Promise.resolve([])
+      ]);
+      return jn(t, p, f);
+    })() : Promise.resolve(null)
+  ]);
+  return { summary: u, permanent: c, token: a, chainNow: u?.now ?? l, readAtMs: Date.now() };
+}
+function Dr(e, n, t = {}) {
+  const o = e.replace(/\/+$/, ""), r = `/${(t.pathBase ?? "/app/locks").replace(/^\/+|\/+$/g, "")}`, s = t.query ? `?${t.query.replace(/^\?/, "")}` : "";
+  return n.kind === "pool" ? `${o}${r}/pool/${n.poolId ?? ""}${s}` : `${o}${r}/token/${n.token ?? ""}${s}`;
+}
+function x(e) {
+  const n = Math.floor(e / 100), t = e % 100;
+  return t === 0 ? `${n}%` : `${n}.${String(t).padStart(2, "0")}%`;
+}
+function Gr(e) {
+  if (e <= 0n) return "now";
+  const n = Number(e), t = Math.floor(n / 86400), o = Math.floor(n % 86400 / 3600), r = Math.floor(n % 3600 / 60), s = n % 60, i = (u) => String(u).padStart(2, "0");
+  return t >= 365 ? `${Math.floor(t / 365)}y ${t % 365}d` : t > 0 ? `${t}d ${i(o)}h ${i(r)}m` : o > 0 ? `${o}h ${i(r)}m ${i(s)}s` : `${r}m ${i(s)}s`;
+}
+function te(e) {
+  return `${new Date(Number(e) * 1e3).toISOString().replace("T", " ").slice(0, 16)} UTC`;
+}
+function D(e, n, t = 6) {
+  if (n.decimals === null) return `${e.toLocaleString("en-US")} base units ${n.symbol}`;
+  if (e === 0n) return `0 ${n.symbol}`;
+  const o = 10n ** BigInt(n.decimals), r = e / o, s = (e % o).toString().padStart(n.decimals, "0").slice(0, t).replace(/0+$/, "");
+  return r === 0n && s === "" ? `<0.${"0".repeat(Math.max(0, t - 1))}1 ${n.symbol}` : `${r.toLocaleString("en-US")}${s === "" ? "" : `.${s}`} ${n.symbol}`;
+}
+const H = (e, n, t) => `${e.toLocaleString("en-US")} ${e === 1 ? n : t}`;
+function uo(e) {
+  const n = e.permanent ?? [], t = n.length > 0;
+  if (e.locks.length === 0 && !t)
+    return { tone: "none", headline: "No locked liquidity", detail: "No position in this pool is time-locked (LatchPositionLock) or held permanently by the protocol's LP locker.", countdownTo: null, countdownLabel: null };
+  if (e.lockedCount === 0 && !t) {
+    const s = e.liveCount;
+    return {
+      tone: "open",
+      headline: "No time-locked positions now",
+      detail: s > 0 ? `${H(s, "lock is", "locks are")} past the unlock date and can be withdrawn by the lock owner.` : "Every lock on this pool has been withdrawn.",
+      countdownTo: null,
+      countdownLabel: null
+    };
+  }
+  const o = e.lockedActiveBps === null ? t && e.lockedCount === 0 ? "Locked permanently (LP locker) · share of active liquidity not measurable" : `${H(e.lockedCount + n.length, "locked position", "locked positions")} · share of active liquidity not measurable` : `${x(e.lockedActiveBps)} of active liquidity locked`, r = [];
+  if (e.lockedActiveBps === null)
+    r.push(e.pool === null ? "The pool's state could not be read." : "The pool has no liquidity at the current price, so no share can be measured.");
+  else {
+    const s = [];
+    t && s.push(`${x(e.permanentActiveBps ?? 0)} locked permanently (LP locker, no withdraw path)`), e.lockedCount > 0 && s.push(`${x(e.timeLockedActiveBps ?? 0)} time-locked until a date`), r.push(`${s.join(", ")}. The share is of liquidity at the current price and moves with it.`);
+    const i = e.outOfRangeLocked + (e.permanentOutOfRange ?? 0);
+    i > 0 && r.push(`${H(i, "locked position is", "locked positions are")} out of range and not counted.`);
+  }
+  return e.lastUnlockAt !== null && e.nextUnlockAt !== null && e.lastUnlockAt !== e.nextUnlockAt && r.push(`Last time-lock unlock ${te(e.lastUnlockAt)}.`), {
+    tone: "locked",
+    headline: o,
+    detail: r.join(" "),
+    countdownTo: e.nextUnlockAt,
+    countdownLabel: e.nextUnlockAt === null ? null : `first time-lock unlock ${te(e.nextUnlockAt)}`
+  };
+}
+function lo(e, n, t) {
+  if (e.locks.length === 0)
+    return { tone: "none", headline: "No locked liquidity", detail: "The protocol's Bin LP locker holds nothing in this pool. Time locks cover CL positions only.", countdownTo: null, countdownLabel: null };
+  const o = `${D(e.amount0, n)} + ${D(e.amount1, t)}`, r = e.locks.reduce((s, i) => s + i.bins.length, 0);
+  return {
+    tone: "locked",
+    headline: e.activeBinLockedBps === null ? "Locked permanently (LP locker)" : `${x(e.activeBinLockedBps)} of the active bin locked permanently (LP locker)`,
+    detail: `${o} held forever by the Bin LP locker across ${H(r, "bin", "bins")}.${e.activeBinLockedBps === null ? " No lock holds the bin that trades at the current price." : " The share is of the bin that trades at the current price; a pool-wide share across all bins is not computed."}`,
+    countdownTo: null,
+    countdownLabel: null
+  };
+}
+function Wr(e, n, t = null) {
+  const o = t !== null && t.pools.length > 0 ? `${D(t.total, n)}${e.totalSupply ? ` (${x(Number(t.total * 10000n / e.totalSupply))} of supply)` : ""} locked permanently as pool liquidity (LP locker) in ${H(t.pools.length, "pool", "pools")}, at the current price.` : null;
+  if (e.locks.length === 0 && o !== null)
+    return { tone: "locked", headline: `${n.symbol} liquidity locked permanently (LP locker)`, detail: `${o} No time lock or vesting of ${n.symbol} with the Latch token lock.`, countdownTo: null, countdownLabel: null };
+  if (e.locks.length === 0)
+    return { tone: "none", headline: `No ${n.symbol} locked`, detail: "No lock of this token has been made with the Latch token lock.", countdownTo: null, countdownLabel: null };
+  if (e.totalHeld === 0n)
+    return {
+      tone: o !== null ? "locked" : "open",
+      headline: o !== null ? `${n.symbol} liquidity locked permanently (LP locker)` : `No ${n.symbol} locked now`,
+      detail: `${H(e.locks.length, "time lock has", "time locks have")} been fully released and claimed.${o !== null ? ` ${o}` : ""}`,
+      countdownTo: null,
+      countdownLabel: null
+    };
+  const r = e.heldBps === null ? `${D(e.totalHeld, n)} held in locks` : `${x(e.heldBps)} of supply held in locks`, s = [];
+  return s.push(
+    e.unvestedBps === null ? `${D(e.unvested, n)} not yet vested.` : `${x(e.unvestedBps)} of supply (${D(e.unvested, n)}) not yet vested; the rest is vested and waiting to be claimed.`
+  ), e.lastEnd !== null && s.push(`Fully vested ${te(e.lastEnd)}.`), o !== null && s.push(o), {
+    tone: e.unvested > 0n ? "locked" : "open",
+    headline: r,
+    detail: s.join(" "),
+    countdownTo: e.nextCliffOrEnd,
+    countdownLabel: e.nextCliffOrEnd === null ? null : `next release ${te(e.nextCliffOrEnd)}`
+  };
+}
+const Kr = {
+  locked: "Locked",
+  unlockable: "Unlockable",
+  withdrawn: "Withdrawn"
+}, Hr = {
+  cliff: "Before cliff",
+  vesting: "Vesting",
+  vested: "Fully vested",
+  claimed: "Claimed"
+};
+function Xr(e) {
+  return e.amount === 0n ? 0 : Number(e.vested * 10000n / e.amount);
+}
+function Vr(e, n, t) {
+  return e + BigInt(Math.max(0, Math.floor((t - n) / 1e3)));
+}
+const ne = (e, n) => {
+  const t = e * 10000n / n;
+  return Number(t > 10000n ? 10000n : t);
+};
+function le(e, n) {
+  return { parts: e.filter((t) => t.bps > 0 || t.nonZero), of: n, restBps: Math.max(0, 1e4 - e.reduce((t, o) => t + o.bps, 0)) };
+}
+function jr(e) {
+  const n = e.pool?.activeLiquidity ?? 0n;
+  if (e.pool === null || n === 0n) return null;
+  const t = e.permanentActiveLiquidity ?? 0n, o = e.timeLockedActiveLiquidity ?? e.lockedActiveLiquidity - t;
+  return le(
+    [
+      { key: "permanent", label: "Locked permanently (LP locker)", bps: ne(t, n), nonZero: t > 0n },
+      { key: "time", label: "Time-locked until a date", bps: ne(o, n), nonZero: o > 0n }
+    ],
+    "of active liquidity"
+  );
+}
+function Yr(e) {
+  return e.activeBinLockedBps === null ? null : le([{ key: "permanent", label: "Locked permanently (LP locker)", bps: e.activeBinLockedBps, nonZero: e.activeBinLockedBps > 0 }], "of the active bin");
+}
+function Zr(e, n = null) {
+  const t = e.totalSupply ?? null;
+  if (t === null || t === 0n) return null;
+  const o = e.totalHeld > e.unvested ? e.totalHeld - e.unvested : 0n, r = n ?? 0n;
+  return le(
+    [
+      { key: "unvested", label: "Not yet vested", bps: ne(e.unvested, t), nonZero: e.unvested > 0n },
+      { key: "vested", label: "Vested, not yet claimed", bps: ne(o, t), nonZero: o > 0n },
+      { key: "lp", label: "In permanent LP (LP locker)", bps: ne(r, t), nonZero: r > 0n }
+    ],
+    "of supply"
+  );
+}
+function Qr(e, n, t = 24) {
+  if (e.length === 0) return null;
+  const o = e.reduce((a, l) => l.start < a ? l.start : a, e[0].start), r = e.reduce((a, l) => l.end > a ? l.end : a, e[0].end);
+  if (r <= o) return null;
+  const s = /* @__PURE__ */ new Set([o, r]);
+  n !== null && n > o && n < r && s.add(n);
+  for (const a of e)
+    s.add(a.start), s.add(a.end), a.cliff > a.start && (s.add(a.cliff - 1n), s.add(a.cliff));
+  const i = (r - o) / BigInt(t);
+  if (i > 0n) for (let a = 1n; a < BigInt(t); a++) s.add(o + i * a);
+  return { points: [...s].sort((a, l) => a < l ? -1 : a > l ? 1 : 0).map((a) => ({ t: a, vested: e.reduce((l, c) => l + Yn(c, a), 0n) })), total: e.reduce((a, l) => a + l.amount, 0n) };
+}
+function zr(e, n) {
+  return e.every((t) => t.bps === null) ? null : le(
+    e.map((t) => ({ key: t.key, label: t.label, bps: t.bps ?? 0, nonZero: !1 })),
+    n
+  );
+}
+function Jr(e) {
+  return e.bin !== null ? lo(e.bin, e.currency0, e.currency1) : uo(e.summary);
+}
+function es(e) {
+  const n = e.summary, t = e.token, o = e.permanent !== null && e.permanent.pools.length > 0 ? e.permanent : null, r = n?.totalSupply ?? null, s = o === null ? null : `${D(o.total, t)}${r !== null && r > 0n ? ` (${x(Number(o.total * 10000n / r))} of supply)` : ""} locked permanently as liquidity (LP locker)`;
+  if (n !== null && n.unvested > 0n) {
+    const i = n.unvestedBps === null ? `${D(n.unvested, t)} locked` : n.unvestedBps === 0 ? "<0.01% of supply locked" : `${x(n.unvestedBps)} of supply locked`, u = [`Not yet vested in ${n.locks.length === 1 ? "1 Latch token lock" : `${n.locks.length.toLocaleString("en-US")} Latch token locks`}.`];
+    return s !== null && u.push(`${s}.`), { tone: "locked", headline: i, detail: u.join(" "), countdownTo: n.nextCliffOrEnd, countdownLabel: n.nextCliffOrEnd === null ? null : `next release ${te(n.nextCliffOrEnd)}` };
+  }
+  return s !== null ? { tone: "locked", headline: "Liquidity locked permanently (LP locker)", detail: `${s}.`, countdownTo: null, countdownLabel: null } : n !== null && n.locks.length > 0 ? { tone: "open", headline: `No ${t.symbol} locked now`, detail: "Every Latch token lock of it has fully vested.", countdownTo: null, countdownLabel: null } : { tone: "none", headline: `No ${t.symbol} locked`, detail: "No Latch token lock or LP-locker liquidity holds it.", countdownTo: null, countdownLabel: null };
+}
+function co(e, n, t) {
+  if (t <= 0n) throw new RangeError("window size must be positive");
+  const o = [];
+  for (let r = e; r <= n; r += t) o.push({ from: r, to: r + t - 1n > n ? n : r + t - 1n });
+  return o;
+}
+async function ns(e, n, t, o) {
+  const r = t.toBlock ?? await e.getBlockNumber(), s = t.minWindow ?? 2000n, i = /* @__PURE__ */ new Set(), u = [], a = async (l, c) => {
+    try {
+      const d = await tn(e, n, { fromBlock: l, toBlock: c }, o);
+      for (const p of d) {
+        const f = p.tokenId.toString();
+        i.has(f) || (i.add(f), u.push(p.tokenId));
+      }
+    } catch (d) {
+      const p = c - l + 1n;
+      if (p <= s) throw d;
+      const f = l + p / 2n;
+      await a(l, f - 1n), await a(f, c);
+    }
+  };
+  for (const l of co(t.fromBlock, r, t.window ?? 500000n)) await a(l.from, l.to);
+  return u;
+}
+export {
+  pr as $,
+  O as A,
+  Mo as B,
+  we as C,
+  so as D,
+  qo as E,
+  Vr as F,
+  ar as G,
+  it as H,
+  Ye as I,
+  cr as J,
+  zn as K,
+  Ho as L,
+  J as M,
+  Co as N,
+  Ge as O,
+  Uo as P,
+  X as Q,
+  io as R,
+  at as S,
+  Hr as T,
+  kt as U,
+  lo as V,
+  ue as W,
+  fr as X,
+  Yr as Y,
+  ae as Z,
+  dr as _,
+  bt as a,
+  Nr as a$,
+  co as a0,
+  Vo as a1,
+  Jo as a2,
+  ct as a3,
+  xt as a4,
+  Nt as a5,
+  Mr as a6,
+  Ir as a7,
+  Re as a8,
+  ft as a9,
+  mt as aA,
+  No as aB,
+  _o as aC,
+  te as aD,
+  Se as aE,
+  $e as aF,
+  Be as aG,
+  Pe as aH,
+  ir as aI,
+  B as aJ,
+  Sr as aK,
+  Rt as aL,
+  Rr as aM,
+  ln as aN,
+  Yt as aO,
+  jt as aP,
+  eo as aQ,
+  yn as aR,
+  _t as aS,
+  Ko as aT,
+  cn as aU,
+  Dr as aV,
+  De as aW,
+  ve as aX,
+  bo as aY,
+  bn as aZ,
+  Or as a_,
+  _e as aa,
+  Jt as ab,
+  Eo as ac,
+  Er as ad,
+  Xo as ae,
+  Te as af,
+  he as ag,
+  hr as ah,
+  no as ai,
+  pn as aj,
+  yr as ak,
+  dn as al,
+  dt as am,
+  ko as an,
+  Fr as ao,
+  Ur as ap,
+  to as aq,
+  Oe as ar,
+  pt as as,
+  Po as at,
+  go as au,
+  Gr as av,
+  xo as aw,
+  D as ax,
+  x as ay,
+  Oo as az,
+  gt as b,
+  kn as b$,
+  ke as b0,
+  Ve as b1,
+  Br as b2,
+  ur as b3,
+  Bo as b4,
+  vo as b5,
+  It as b6,
+  uo as b7,
+  Jr as b8,
+  qr as b9,
+  lr as bA,
+  ge as bB,
+  tr as bC,
+  br as bD,
+  wr as bE,
+  A as bF,
+  $o as bG,
+  zo as bH,
+  er as bI,
+  Zo as bJ,
+  Qo as bK,
+  Lo as bL,
+  sr as bM,
+  rr as bN,
+  kr as bO,
+  So as bP,
+  gr as bQ,
+  jo as bR,
+  Ht as bS,
+  Vt as bT,
+  or as bU,
+  nr as bV,
+  $r as bW,
+  E as bX,
+  et as bY,
+  Xr as bZ,
+  vr as b_,
+  jr as ba,
+  _r as bb,
+  xr as bc,
+  Io as bd,
+  ut as be,
+  lt as bf,
+  To as bg,
+  Tr as bh,
+  Qr as bi,
+  wo as bj,
+  tt as bk,
+  Yo as bl,
+  Lr as bm,
+  Pr as bn,
+  ao as bo,
+  ns as bp,
+  zr as bq,
+  wt as br,
+  ot as bs,
+  Cr as bt,
+  hn as bu,
+  Wr as bv,
+  es as bw,
+  Zr as bx,
+  Ar as by,
+  wn as bz,
+  U as c,
+  me as d,
+  Ro as e,
+  G as f,
+  st as g,
+  Xe as h,
+  F as i,
+  _ as j,
+  Le as k,
+  Do as l,
+  Wo as m,
+  Go as n,
+  Ae as o,
+  sn as p,
+  nt as q,
+  Ft as r,
+  rt as s,
+  vt as t,
+  Fo as u,
+  Kr as v,
+  Mt as w,
+  Ce as x,
+  Ao as y,
+  mr as z
+};
+//# sourceMappingURL=scan-Dhu7f4Nl.js.map