@latchprotocol/widgets 0.1.0

package/dist/chunks/useLocker-D1c_NTk-.js

@@ -0,0 +1,1613 @@
+import { encodeAbiParameters as A, encodeFunctionData as $, isAddressEqual as b, BaseError as J, ExecutionRevertedError as Z, decodeAbiParameters as Le, zeroAddress as Ie, parseUnits as Ae } from "viem";
+import { NATIVE_CURRENCY as Ce, quoterAbiFor as Te, isDynamicLPFee as Me, BIN_LAUNCH_GUARD_HOOK_ABI as ee, readBinPoolKeyParameters as te, binRawPriceFromId as ne, poolKeyToId as oe, readCLPoolKeyParameters as Ne, LAUNCHPAD_KIT_V2_ABI as Se, getDeployment as $e, CLOCK_MODE_CALLDATA as Pe, TIMESTAMP_CLOCK_MODE as Be, readContractClock as xe, readTokenMeta as De } from "@latchprotocol/sdk";
+import { B as O, b6 as F, A as C, t as j, u as G, p as Q, E as N, w as f, bj as L, P as ie, m as Oe, l as Ee, n as _e, aT as ae, W as E, a4 as Re, bu as Fe, aI as Ge, aJ as se, G as U, _ as qe, bA as Ue, X as re, ae as Ke, aN as Xe, aY as Ye, F as We, b$ as me, bF as P, b9 as He, ao as Ve, ap as je, bx as Qe, bq as ce, aj as ze, bL as Je } from "./scan-Dhu7f4Nl.js";
+import { useState as he, useEffect as Ze, useRef as et, useCallback as ue, useMemo as tt } from "react";
+import { describeTokenLocks as nt, describeLaunch as ot, summarizeTokenTrust as it, describeLiquidity as at, describeLpFee as st, describeProtocolFee as rt, describeCreatorTax as ye, describeRegistry as ct, formatTrustSource as ut, readTokenTrust as lt } from "@latchprotocol/sdk/trust";
+import { readFeeGate as le, readChainNow as dt, readPositionLocksOf as pt, readBeneficiaryLocks as mt } from "@latchprotocol/sdk/lock";
+function ht(t, e, o) {
+  if (t > e)
+    throw new RangeError(`binIdLower ${t} exceeds binIdUpper ${e}`);
+  const n = [];
+  for (let p = t; p <= e; p += 1) n.push(p);
+  const a = n.filter((p) => p >= o).length, i = n.filter((p) => p <= o).length, s = e, r = Math.min(o, e), l = [];
+  let c = 0n, d = 0n;
+  for (const p of n) {
+    const m = p >= o && a > 0 ? O / BigInt(a) : 0n, u = p <= o && i > 0 ? O / BigInt(i) : 0n, h = p === s && m > 0n ? O - c : m, y = p === r && u > 0n ? O - d : u;
+    c += h, d += y, l.push({ binId: p, deltaId: p - o, distributionX: h, distributionY: y });
+  }
+  return l;
+}
+class Et extends Error {
+  constructor() {
+    super(
+      "[@latchprotocol/widgets] no sale adapter is configured. Latch has no sale contract - a launch is a pool with LaunchGuardHook attached, and buying into one is a swap. Set ProtocolAdapter.sale only if you run your own sale contract."
+    ), this.name = "NoSaleAdapterError";
+  }
+}
+function _t(t) {
+  return t.sale !== void 0;
+}
+const yt = [
+  { name: "poolKey", type: "tuple", components: j },
+  { name: "tickLower", type: "int24" },
+  { name: "tickUpper", type: "int24" },
+  { name: "liquidity", type: "uint256" },
+  { name: "amount0Max", type: "uint128" },
+  { name: "amount1Max", type: "uint128" },
+  { name: "owner", type: "address" },
+  { name: "hookData", type: "bytes" }
+], ft = [
+  { name: "tokenId", type: "uint256" },
+  { name: "liquidity", type: "uint256" },
+  { name: "amount0", type: "uint128" },
+  { name: "amount1", type: "uint128" },
+  { name: "hookData", type: "bytes" }
+], fe = [
+  { name: "currency0", type: "address" },
+  { name: "currency1", type: "address" }
+], ke = [
+  { name: "currency0", type: "address" },
+  { name: "currency1", type: "address" },
+  { name: "recipient", type: "address" }
+], kt = [
+  { name: "currency", type: "address" },
+  { name: "to", type: "address" }
+];
+function be() {
+  return [
+    C.SWEEP,
+    A(kt, [Ce, Q]),
+    "sweep unspent native value back to the caller"
+  ];
+}
+const bt = [
+  {
+    name: "params",
+    type: "tuple",
+    components: [
+      { name: "poolKey", type: "tuple", components: j },
+      { name: "amount0", type: "uint128" },
+      { name: "amount1", type: "uint128" },
+      { name: "amount0Max", type: "uint128" },
+      { name: "amount1Max", type: "uint128" },
+      { name: "activeIdDesired", type: "uint256" },
+      { name: "idSlippage", type: "uint256" },
+      { name: "deltaIds", type: "int256[]" },
+      { name: "distributionX", type: "uint256[]" },
+      { name: "distributionY", type: "uint256[]" },
+      { name: "minLiquidities", type: "uint256[]" },
+      { name: "to", type: "address" },
+      { name: "hookData", type: "bytes" }
+    ]
+  }
+], wt = [
+  {
+    name: "params",
+    type: "tuple",
+    components: [
+      { name: "poolKey", type: "tuple", components: j },
+      { name: "amount0Min", type: "uint128" },
+      { name: "amount1Min", type: "uint128" },
+      { name: "ids", type: "uint256[]" },
+      { name: "amounts", type: "uint256[]" },
+      { name: "from", type: "address" },
+      { name: "hookData", type: "bytes" }
+    ]
+  }
+];
+function z(t) {
+  return {
+    currency0: t.currency0,
+    currency1: t.currency1,
+    hooks: t.hooks,
+    poolManager: t.poolManager,
+    fee: t.fee,
+    parameters: t.parameters
+  };
+}
+function gt(t) {
+  if (At(t.tickLower, t.tickUpper), t.liquidity <= 0n)
+    throw new RangeError(`[@latchprotocol/widgets] liquidity must be positive: ${t.liquidity}`);
+  const e = F().add(
+    C.CL_MINT_POSITION,
+    A(yt, [
+      z(t.poolKey),
+      t.tickLower,
+      t.tickUpper,
+      t.liquidity,
+      t.amount0Max,
+      t.amount1Max,
+      t.owner,
+      t.hookData ?? "0x"
+    ]),
+    `mint CL position [${t.tickLower}, ${t.tickUpper}]`
+  ).add(
+    C.SETTLE_PAIR,
+    A(fe, [t.poolKey.currency0, t.poolKey.currency1]),
+    "settle both currencies from the caller"
+  );
+  return (t.value ?? 0n) > 0n && e.add(...be()), {
+    to: t.positionManager,
+    data: $({
+      abi: G,
+      functionName: "modifyLiquidities",
+      args: [e.encode(), t.deadline]
+    }),
+    value: t.value ?? 0n,
+    planTrace: e.describe()
+  };
+}
+function vt(t) {
+  if (t.liquidity <= 0n)
+    throw new RangeError(
+      `[@latchprotocol/widgets] liquidity to remove must be positive: ${t.liquidity}`
+    );
+  const e = t.recipient === t.owner ? Q : t.recipient, o = F().add(
+    C.CL_DECREASE_LIQUIDITY,
+    A(ft, [
+      t.tokenId,
+      t.liquidity,
+      t.amount0Min,
+      t.amount1Min,
+      t.hookData ?? "0x"
+    ]),
+    `decrease CL position #${t.tokenId} by ${t.liquidity}`
+  ).add(
+    C.TAKE_PAIR,
+    A(ke, [
+      t.poolKey.currency0,
+      t.poolKey.currency1,
+      e
+    ]),
+    "take both currencies to the recipient"
+  );
+  return {
+    to: t.positionManager,
+    data: $({
+      abi: G,
+      functionName: "modifyLiquidities",
+      args: [o.encode(), t.deadline]
+    }),
+    value: 0n,
+    planTrace: o.describe()
+  };
+}
+function Lt(t) {
+  const e = t.deltaIds.length;
+  if (e === 0)
+    throw new RangeError("[@latchprotocol/widgets] a bin mint must target at least one bin");
+  if (t.distributionX.length !== e || t.distributionY.length !== e)
+    throw new RangeError(
+      "[@latchprotocol/widgets] deltaIds, distributionX and distributionY must be the same length"
+    );
+  if (!Number.isInteger(t.activeIdDesired) || t.activeIdDesired < 0)
+    throw new RangeError(
+      `[@latchprotocol/widgets] activeIdDesired must be a non-negative integer: ${t.activeIdDesired}`
+    );
+  const o = F().add(
+    C.BIN_ADD_LIQUIDITY,
+    A(bt, [
+      {
+        poolKey: z(t.poolKey),
+        amount0: t.amount0,
+        amount1: t.amount1,
+        amount0Max: t.amount0Max,
+        amount1Max: t.amount1Max,
+        activeIdDesired: BigInt(t.activeIdDesired),
+        idSlippage: BigInt(t.idSlippage),
+        deltaIds: t.deltaIds.map((n) => BigInt(n)),
+        distributionX: [...t.distributionX],
+        distributionY: [...t.distributionY],
+        // One entry per bin. Zero means "accept whatever the pool mints"; the
+        // real slippage guard for a bin mint is idSlippage plus amountNMax.
+        minLiquidities: t.deltaIds.map(() => 0n),
+        to: t.to,
+        hookData: t.hookData ?? "0x"
+      }
+    ]),
+    `add bin liquidity across ${e} bins around id ${t.activeIdDesired}`
+  ).add(
+    C.SETTLE_PAIR,
+    A(fe, [t.poolKey.currency0, t.poolKey.currency1]),
+    "settle both currencies from the caller"
+  );
+  return (t.value ?? 0n) > 0n && o.add(...be()), {
+    to: t.positionManager,
+    data: $({
+      abi: G,
+      functionName: "modifyLiquidities",
+      args: [o.encode(), t.deadline]
+    }),
+    value: t.value ?? 0n,
+    planTrace: o.describe()
+  };
+}
+function It(t) {
+  if (t.ids.length === 0)
+    throw new RangeError("[@latchprotocol/widgets] a bin burn must target at least one bin");
+  if (t.ids.length !== t.amounts.length)
+    throw new RangeError("[@latchprotocol/widgets] ids and amounts must be the same length");
+  const e = t.recipient === t.from ? Q : t.recipient, o = F().add(
+    C.BIN_REMOVE_LIQUIDITY,
+    A(wt, [
+      {
+        poolKey: z(t.poolKey),
+        amount0Min: t.amount0Min,
+        amount1Min: t.amount1Min,
+        ids: t.ids.map((n) => BigInt(n)),
+        amounts: [...t.amounts],
+        from: t.from,
+        hookData: t.hookData ?? "0x"
+      }
+    ]),
+    `remove bin liquidity from ${t.ids.length} bins`
+  ).add(
+    C.TAKE_PAIR,
+    A(ke, [
+      t.poolKey.currency0,
+      t.poolKey.currency1,
+      e
+    ]),
+    "take both currencies to the recipient"
+  );
+  return {
+    to: t.positionManager,
+    data: $({
+      abi: G,
+      functionName: "modifyLiquidities",
+      args: [o.encode(), t.deadline]
+    }),
+    value: 0n,
+    planTrace: o.describe()
+  };
+}
+function At(t, e) {
+  if (!Number.isInteger(t) || !Number.isInteger(e))
+    throw new RangeError(
+      `[@latchprotocol/widgets] ticks must be integers: [${t}, ${e}]`
+    );
+  if (t >= e)
+    throw new RangeError(
+      `[@latchprotocol/widgets] tickLower must be below tickUpper: [${t}, ${e}]`
+    );
+}
+const K = [
+  {
+    type: "function",
+    name: "getSlot0",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [
+      { name: "sqrtPriceX96", type: "uint160" },
+      { name: "tick", type: "int24" },
+      { name: "protocolFee", type: "uint24" },
+      { name: "lpFee", type: "uint24" }
+    ]
+  }
+], X = [
+  {
+    type: "function",
+    name: "getSlot0",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [
+      { name: "activeId", type: "uint24" },
+      { name: "protocolFee", type: "uint24" },
+      { name: "lpFee", type: "uint24" }
+    ]
+  }
+], de = 2n ** 192n, _ = [
+  {
+    type: "function",
+    name: "getLiquidity",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [{ name: "liquidity", type: "uint128" }]
+  },
+  {
+    type: "function",
+    name: "getFeeGrowthGlobals",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "bytes32" }],
+    outputs: [
+      { name: "feeGrowthGlobal0x128", type: "uint256" },
+      { name: "feeGrowthGlobal1x128", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "getPoolTickInfo",
+    stateMutability: "view",
+    inputs: [
+      { name: "id", type: "bytes32" },
+      { name: "tick", type: "int24" }
+    ],
+    outputs: [
+      {
+        name: "info",
+        type: "tuple",
+        components: [
+          { name: "liquidityGross", type: "uint128" },
+          { name: "liquidityNet", type: "int128" },
+          { name: "feeGrowthOutside0X128", type: "uint256" },
+          { name: "feeGrowthOutside1X128", type: "uint256" }
+        ]
+      }
+    ]
+  }
+], pe = [
+  {
+    type: "function",
+    name: "getBin",
+    stateMutability: "view",
+    inputs: [
+      { name: "id", type: "bytes32" },
+      { name: "binId", type: "uint24" }
+    ],
+    outputs: [
+      { name: "binReserveX", type: "uint128" },
+      { name: "binReserveY", type: "uint128" },
+      { name: "binLiquidity", type: "uint256" },
+      { name: "totalShares", type: "uint256" }
+    ]
+  }
+], we = {
+  name: "poolKey",
+  type: "tuple",
+  components: [
+    { name: "currency0", type: "address" },
+    { name: "currency1", type: "address" },
+    { name: "hooks", type: "address" },
+    { name: "poolManager", type: "address" },
+    { name: "fee", type: "uint24" },
+    { name: "parameters", type: "bytes32" }
+  ]
+}, Y = [
+  {
+    type: "function",
+    name: "ownerOf",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "uint256" }],
+    outputs: [{ name: "owner", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "positions",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [
+      we,
+      { name: "tickLower", type: "int24" },
+      { name: "tickUpper", type: "int24" },
+      { name: "liquidity", type: "uint128" },
+      { name: "feeGrowthInside0LastX128", type: "uint256" },
+      { name: "feeGrowthInside1LastX128", type: "uint256" },
+      { name: "subscriber", type: "address" }
+    ]
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: !0 },
+      { name: "to", type: "address", indexed: !0 },
+      { name: "id", type: "uint256", indexed: !0 }
+    ]
+  }
+], W = [
+  {
+    type: "function",
+    name: "positions",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [we, { name: "binId", type: "uint24" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    outputs: [{ name: "balance", type: "uint256" }]
+  },
+  {
+    type: "event",
+    name: "TransferBatch",
+    inputs: [
+      { name: "sender", type: "address", indexed: !0 },
+      { name: "from", type: "address", indexed: !0 },
+      { name: "to", type: "address", indexed: !0 },
+      { name: "ids", type: "uint256[]", indexed: !1 },
+      { name: "amounts", type: "uint256[]", indexed: !1 }
+    ]
+  }
+], S = "0x0000000000000000000000000000000000000000";
+class Ct {
+  kind = "viem";
+  isMock = !1;
+  chain;
+  #t;
+  constructor(e) {
+    this.#t = e, this.chain = e.chain;
+  }
+  get #e() {
+    return this.#t.publicClient;
+  }
+  get #n() {
+    return this.#t.overrides ?? {};
+  }
+  async getAccount() {
+    const e = this.#t.wallet;
+    return e === void 0 ? null : e.getAccount();
+  }
+  async listTokens() {
+    return this.#t.tokens;
+  }
+  async getToken(e) {
+    const o = this.#t.tokens.find((s) => b(s.address, e));
+    if (o !== void 0) return o;
+    if (b(e, S))
+      return {
+        address: S,
+        symbol: this.chain.nativeCurrency.symbol,
+        name: this.chain.nativeCurrency.name,
+        decimals: this.chain.nativeCurrency.decimals,
+        isNative: !0
+      };
+    const [n, a, i] = await Promise.all([
+      this.#e.readContract({ address: e, abi: N, functionName: "symbol" }),
+      this.#e.readContract({ address: e, abi: N, functionName: "name" }),
+      this.#e.readContract({ address: e, abi: N, functionName: "decimals" })
+    ]);
+    return { address: e, symbol: n, name: a, decimals: Number(i) };
+  }
+  async getBalance(e, o) {
+    return e.isNative === !0 || b(e.address, S) ? this.#e.getBalance({ address: o }) : this.#e.readContract({
+      address: e.address,
+      abi: N,
+      functionName: "balanceOf",
+      args: [o]
+    });
+  }
+  async listPools() {
+    return this.#t.pools;
+  }
+  /**
+   * The pool's live state from its manager's `getSlot0` (plus `getLiquidity`
+   * for a CL pool). An uninitialised pool answers a zero price, which is
+   * reported as an error rather than as tick 0.
+   */
+  async getPoolState(e) {
+    const o = this.#n.getPoolState;
+    if (o !== void 0) return o(e);
+    if (e.poolType === "CL") {
+      const [[a, i], s] = await Promise.all([
+        this.#e.readContract({ address: e.key.poolManager, abi: K, functionName: "getSlot0", args: [e.id] }),
+        this.#e.readContract({ address: e.key.poolManager, abi: _, functionName: "getLiquidity", args: [e.id] })
+      ]);
+      if (a === 0n)
+        throw new f("getPoolState", `pool ${e.id} is not initialised on ${e.key.poolManager}`);
+      return { poolId: e.id, poolType: "CL", currentTick: i, sqrtPriceX96: a, liquidity: s, source: "live" };
+    }
+    const [n] = await this.#e.readContract({ address: e.key.poolManager, abi: X, functionName: "getSlot0", args: [e.id] });
+    if (n === 0)
+      throw new f("getPoolState", `pool ${e.id} is not initialised on ${e.key.poolManager}`);
+    return { poolId: e.id, poolType: "BIN", activeId: n, source: "live" };
+  }
+  /**
+   * The two allowances `spender` needs before it can pull `token` through
+   * Permit2: ERC-20 to Permit2, then Permit2 to the spender. The spender is
+   * the router for a swap (the default) and a position manager for a
+   * liquidity add; the liquidity hooks pass it, because an allowance to the
+   * router does nothing for a mint.
+   */
+  async getApprovalRequirements(e, o, n, a) {
+    if (e.isNative === !0 || b(e.address, S)) return [];
+    const i = L(this.chain, "permit2", "pull the input token for a swap"), s = a ?? L(this.chain, "universalRouter", "execute a swap"), r = [], l = await this.#e.readContract({
+      address: e.address,
+      abi: N,
+      functionName: "allowance",
+      args: [o, i]
+    });
+    l < n && r.push({
+      kind: "erc20-to-permit2",
+      token: e,
+      spender: i,
+      current: l,
+      required: n
+    });
+    const [c, d] = await this.#e.readContract({
+      address: i,
+      abi: ie,
+      functionName: "allowance",
+      args: [o, e.address, s]
+    }), p = BigInt(Math.floor(Date.now() / 1e3)), m = BigInt(d) !== 0n && BigInt(d) <= p;
+    return (BigInt(c) < n || m) && r.push({
+      kind: "permit2-to-router",
+      token: e,
+      spender: s,
+      current: m ? 0n : BigInt(c),
+      required: n
+    }), r;
+  }
+  async buildApproval(e) {
+    return e.kind === "erc20-to-permit2" ? {
+      to: e.token.address,
+      data: $({
+        abi: N,
+        functionName: "approve",
+        args: [e.spender, Oe]
+      }),
+      value: 0n,
+      summary: `Approve ${e.token.symbol} for Permit2`,
+      source: "live"
+    } : {
+      to: L(this.chain, "permit2", "approve the router through Permit2"),
+      data: $({
+        abi: ie,
+        functionName: "approve",
+        args: [e.token.address, e.spender, Ee, Number(_e)]
+      }),
+      value: 0n,
+      summary: `Approve ${e.spender} to spend ${e.token.symbol} via Permit2`,
+      source: "live"
+    };
+  }
+  /**
+   * Quotes an exact-input swap.
+   *
+   * With `overrides.quoteSwap` the host answers. Otherwise every configured
+   * pool holding both tokens is quoted DIRECTLY against the deployed quoter for
+   * its type (`contracts.quoter` for CL, `contracts.binQuoter` for Bin) and the
+   * best output wins. No multi-hop routing: a route this adapter did not quote
+   * is a route it cannot vouch for. Throws when no quoter can answer.
+   *
+   * The LP fee shown beside the quote is the pool's static fee, or, for a
+   * dynamic-fee pool whose hook is a launch guard, the guard's `currentFee`.
+   * Any other dynamic pool is reported `lpFeeUnknown`, which the widget renders
+   * as "dynamic" rather than as a rate it did not read.
+   */
+  async quoteSwap(e) {
+    const o = this.#n.quoteSwap;
+    if (o !== void 0) return o(e, this.#t.pools);
+    const n = this.chain.contracts, a = this.#t.pools.filter(
+      (u) => (e.poolId === void 0 || u.id === e.poolId) && (b(u.token0.address, e.tokenIn.address) && b(u.token1.address, e.tokenOut.address) || b(u.token1.address, e.tokenIn.address) && b(u.token0.address, e.tokenOut.address))
+    );
+    if (a.length === 0)
+      throw new f(
+        "quoteSwap",
+        e.poolId !== void 0 ? `pool ${e.poolId} is not a configured pool holding both ${e.tokenIn.symbol} and ${e.tokenOut.symbol}.` : `no configured pool holds both ${e.tokenIn.symbol} and ${e.tokenOut.symbol}. This adapter quotes direct pools only; supply \`overrides.quoteSwap\` for multi-hop routes.`
+      );
+    const i = a.filter(
+      (u) => u.poolType === "CL" ? n.quoter !== void 0 : n.binQuoter !== void 0
+    );
+    if (i.length === 0)
+      throw new f(
+        "quoteSwap",
+        `a pool for this pair exists but no quoter is configured for its type (${a.map((u) => u.poolType).join(", ")}). Set \`contracts.quoter\` (CL) / \`contracts.binQuoter\` (Bin), or supply \`overrides.quoteSwap\`. This adapter will not estimate a price it cannot verify.`
+      );
+    const s = await Promise.all(
+      i.map(async (u) => {
+        const h = u.poolType === "CL" ? n.quoter : n.binQuoter;
+        try {
+          const { result: y } = await this.#e.simulateContract({
+            address: h,
+            abi: Te(u.poolType),
+            functionName: "quoteExactInputSingle",
+            args: [
+              {
+                poolKey: u.key,
+                zeroForOne: b(u.key.currency0, e.tokenIn.address),
+                exactAmount: e.amountIn,
+                hookData: "0x"
+              }
+            ]
+          }), [w, k] = y;
+          return { pool: u, amountOut: w, gasEstimate: k, error: null };
+        } catch (y) {
+          return { pool: u, amountOut: 0n, gasEstimate: 0n, error: y instanceof Error ? y : new Error(String(y)) };
+        }
+      })
+    ), r = s.filter((u) => u.error === null);
+    if (r.length === 0) {
+      const u = s[0]?.error;
+      throw new f(
+        "quoteSwap",
+        `every direct pool for this pair failed to quote${u == null ? "" : `: ${u.message}`}`
+      );
+    }
+    const l = r.reduce((u, h) => h.amountOut > u.amountOut ? h : u), c = l.pool;
+    let d = c.lpFeePips, p = !1;
+    if (Me(c.lpFeePips)) {
+      const u = await this.#c(c);
+      u === null ? (d = 0, p = !0) : d = u;
+    }
+    const m = p ? null : await this.#u(c, e.tokenIn.address, e.amountIn, d);
+    return {
+      route: [
+        {
+          poolId: c.id,
+          poolType: c.poolType,
+          tokenIn: e.tokenIn,
+          tokenOut: e.tokenOut,
+          lpFeePips: d,
+          hooks: c.hooks
+        }
+      ],
+      amountIn: e.amountIn,
+      grossAmountOut: l.amountOut,
+      spotAmountOut: m,
+      lpFeeAmount: e.amountIn * BigInt(d) / 1000000n,
+      lpFeePips: d,
+      ...p ? { lpFeeUnknown: p } : {},
+      estimatedGas: l.gasEstimate,
+      source: "live"
+    };
+  }
+  /**
+   * `currentFee(poolId)` when the pool's hook is one of the configured launch
+   * guards; `null` when the hook is not a guard (the fee is then genuinely
+   * unreadable in advance). A guard that REVERTS `currentFee` — an unclaimed
+   * pool id — is also `null`. Anything else (transport failure, an unknown
+   * `CLOCK_MODE`) is thrown: an unreachable RPC is an error state, never a
+   * quote annotated "dynamic".
+   */
+  async #c(e) {
+    const o = this.#o(e);
+    if (o === null) return null;
+    const n = o.poolType === "CL" ? ae(await this.#r(o.hook, "CL")) : ee;
+    try {
+      const a = await this.#e.readContract({ address: o.hook, abi: n, functionName: "currentFee", args: [e.id] });
+      return Number(a);
+    } catch (a) {
+      if (a instanceof J && a.walk((i) => i instanceof Z) !== null)
+        return null;
+      throw a;
+    }
+  }
+  /** The configured launch guard this pool names, if any, with the pool type it serves. */
+  #o(e) {
+    const { launchGuardHook: o, binLaunchGuardHook: n } = this.chain.contracts;
+    return e.poolType === "CL" && o !== void 0 && b(e.hooks, o) ? { hook: o, poolType: "CL" } : e.poolType === "BIN" && n !== void 0 && b(e.hooks, n) ? { hook: n, poolType: "BIN" } : null;
+  }
+  /** `amountIn` priced at the pool's spot from `getSlot0`, less `lpFeePips`; `null` when the read fails. */
+  async #u(e, o, n, a) {
+    const i = b(e.key.currency0, o), s = n * BigInt(1e6 - a) / 1000000n;
+    try {
+      if (e.poolType === "CL") {
+        const [m] = await this.#e.readContract({ address: e.key.poolManager, abi: K, functionName: "getSlot0", args: [e.id] });
+        if (m === 0n) return null;
+        const u = m * m;
+        return i ? s * u / de : s * de / u;
+      }
+      const [r] = await this.#e.readContract({ address: e.key.poolManager, abi: X, functionName: "getSlot0", args: [e.id] }), { binStep: l } = te(e.key), c = ne(Number(r), l);
+      if (!Number.isFinite(c) || c <= 0) return null;
+      const d = 10n ** 18n, p = BigInt(Math.round(c * 1e18));
+      return p === 0n ? null : i ? s * p / d : s * d / p;
+    } catch {
+      return null;
+    }
+  }
+  async buildSwap(e) {
+    const o = L(this.chain, "universalRouter", "execute a swap"), n = await this.getAccount();
+    if (n === null) throw new E("build a swap");
+    const a = this.#l(e), i = Re({
+      router: o,
+      hops: a,
+      amountIn: e.amountIn,
+      minAmountOutGross: e.minAmountOutGross,
+      minAmountOutNet: e.minAmountOutNet,
+      expectedAmountOutGross: e.quote.grossAmountOut,
+      integrator: e.integrator,
+      recipient: e.recipient,
+      sender: n,
+      deadline: e.deadline
+    });
+    return {
+      to: i.to,
+      data: i.data,
+      value: i.value,
+      summary: `Swap ${e.tokenIn.symbol} for ${e.tokenOut.symbol}`,
+      ...i.integratorFee ? {
+        integratorFee: {
+          referrer: i.integratorFee.referrer,
+          feeBps: i.integratorFee.feeBps,
+          currency: i.integratorFee.currency,
+          expectedAmount: i.integratorFee.expectedAmount
+        }
+      } : {},
+      source: "live"
+    };
+  }
+  #l(e) {
+    const o = this.#n.findRoute;
+    if (o !== void 0)
+      return o(e.tokenIn, e.tokenOut, this.#t.pools);
+    const n = [];
+    for (const a of e.quote.route) {
+      const i = this.#t.pools.find((s) => s.id === a.poolId);
+      if (i === void 0)
+        throw new f(
+          "buildSwap",
+          `the quote routes through pool ${a.poolId}, which is not in the configured pool list`
+        );
+      n.push({
+        poolKey: i.key,
+        poolType: i.poolType,
+        currencyIn: a.tokenIn.address,
+        currencyOut: a.tokenOut.address,
+        ...e.hookData ? { hookData: e.hookData } : {}
+      });
+    }
+    return n;
+  }
+  /**
+   * Turns desired amounts into the liquidity the pool will mint and the
+   * amounts it will pull, from live state and the pool's own formulas
+   * (`core/clMath.ts`; `adapters/binDistribution.ts`). The amounts reported
+   * are what the position manager settles: an add rounds towards the pool.
+   */
+  async quoteAddLiquidity(e) {
+    const o = this.#n.quoteAddLiquidity;
+    if (o !== void 0) return o(e);
+    const { pool: n, range: a } = e;
+    if (a.type === "CL") {
+      if (n.poolType !== "CL")
+        throw new f("quoteAddLiquidity", "tick range given for a bin pool");
+      const h = Fe(n);
+      if (a.tickLower % h !== 0 || a.tickUpper % h !== 0)
+        throw new RangeError(
+          `[@latchprotocol/widgets] ticks must be multiples of the pool's spacing ${h}: [${a.tickLower}, ${a.tickUpper}]`
+        );
+      const y = await this.getPoolState(n), w = y.sqrtPriceX96, k = Ge(
+        w,
+        se(a.tickLower),
+        se(a.tickUpper),
+        e.amount0Desired,
+        e.amount1Desired
+      );
+      if (k === 0n)
+        throw new f(
+          "quoteAddLiquidity",
+          "these amounts mint no liquidity in this range: at the pool's price the range needs the other token, or the amounts are too small"
+        );
+      const T = U(w, a.tickLower, a.tickUpper, k, !0), B = y.currentTick >= a.tickLower && y.currentTick < a.tickUpper, g = y.liquidity ?? 0n, M = B ? Number(k * 10000n / (g + k)) : null;
+      return { pool: n, range: a, amount0: T.amount0, amount1: T.amount1, liquidity: k, shareBps: M, source: "live" };
+    }
+    if (n.poolType !== "BIN")
+      throw new f("quoteAddLiquidity", "bin range given for a CL pool");
+    const s = (await this.getPoolState(n)).activeId;
+    if (Math.abs(s - a.activeIdDesired) > a.idSlippage)
+      throw new f(
+        "quoteAddLiquidity",
+        `the active bin is ${s}, more than ${a.idSlippage} bins from the ${a.activeIdDesired} the range was built around; rebuild the range`
+      );
+    const r = ht(a.binIdLower, a.binIdUpper, a.activeIdDesired), l = r.some((h) => h.distributionX > 0n), c = r.some((h) => h.distributionY > 0n), d = l ? e.amount0Desired : 0n, p = c ? e.amount1Desired : 0n;
+    if (d + p === 0n)
+      throw new f(
+        "quoteAddLiquidity",
+        "nothing to deposit: the chosen bins take only the token whose amount is zero"
+      );
+    const m = qe(n);
+    let u = 0n;
+    for (const h of r) {
+      const y = d * h.distributionX / 10n ** 18n, w = p * h.distributionY / 10n ** 18n, k = ne(h.binId, m);
+      u += BigInt(Math.floor(Number(y) * k)) + w;
+    }
+    return { pool: n, range: a, amount0: d, amount1: p, liquidity: u, shareBps: null, binDistribution: r, source: "live" };
+  }
+  async buildAddLiquidity(e) {
+    if (await this.getAccount() === null) throw new E("add liquidity");
+    const { quote: n } = e, a = this.#d(n.pool, e.amount0Max, e.amount1Max);
+    if (n.range.type === "CL") {
+      const l = L(
+        this.chain,
+        "clPositionManager",
+        "mint a concentrated-liquidity position"
+      ), c = gt({
+        positionManager: l,
+        poolKey: n.pool.key,
+        tickLower: n.range.tickLower,
+        tickUpper: n.range.tickUpper,
+        liquidity: n.liquidity,
+        amount0Max: e.amount0Max,
+        amount1Max: e.amount1Max,
+        owner: e.recipient,
+        deadline: e.deadline,
+        value: a,
+        ...e.hookData ? { hookData: e.hookData } : {}
+      });
+      return {
+        to: c.to,
+        data: c.data,
+        value: c.value,
+        summary: `Add liquidity to ${n.pool.token0.symbol}/${n.pool.token1.symbol}`,
+        source: "live"
+      };
+    }
+    const i = L(
+      this.chain,
+      "binPositionManager",
+      "add liquidity to a bin pool"
+    ), s = n.binDistribution;
+    if (s === void 0 || s.length === 0)
+      throw new f(
+        "buildAddLiquidity",
+        "a bin mint needs a per-bin distribution; the quote did not supply one"
+      );
+    const r = Lt({
+      positionManager: i,
+      poolKey: n.pool.key,
+      amount0: n.amount0,
+      amount1: n.amount1,
+      amount0Max: e.amount0Max,
+      amount1Max: e.amount1Max,
+      activeIdDesired: n.range.activeIdDesired,
+      idSlippage: n.range.idSlippage,
+      deltaIds: s.map((l) => l.deltaId),
+      distributionX: s.map((l) => l.distributionX),
+      distributionY: s.map((l) => l.distributionY),
+      to: e.recipient,
+      deadline: e.deadline,
+      value: a,
+      ...e.hookData ? { hookData: e.hookData } : {}
+    });
+    return {
+      to: r.to,
+      data: r.data,
+      value: r.value,
+      summary: `Add liquidity to ${n.pool.token0.symbol}/${n.pool.token1.symbol}`,
+      source: "live"
+    };
+  }
+  #d(e, o, n) {
+    return b(e.token0.address, S) ? o : b(e.token1.address, S) ? n : 0n;
+  }
+  /**
+   * A holder's positions, reconstructed from position-manager logs and
+   * confirmed against live state. Needs `positionsFromBlock`.
+   *
+   * CL: `Transfer(to = owner)` candidates, each confirmed by `ownerOf`, then
+   * `positions(tokenId)` for the key, ticks and liquidity; amounts and fees
+   * from the pool's slot0, tick info and fee-growth globals, exactly as the
+   * pool would credit them. Bin: `TransferBatch(to = owner)` candidates, each
+   * confirmed by `balanceOf`, grouped by pool; amounts from each bin's
+   * reserves and share supply. A position on a pool not in the configured
+   * list still appears, with its tokens read off their contracts.
+   */
+  async listPositions(e, o) {
+    const n = this.#n.listPositions;
+    if (n !== void 0) return n(e, o);
+    const a = this.#t.positionsFromBlock;
+    if (a === void 0)
+      throw new f(
+        "listPositions",
+        "position enumeration scans the position managers' transfer logs and needs `positionsFromBlock` (the block they were deployed at) in the adapter options."
+      );
+    const i = o?.poolType, [s, r] = await Promise.all([
+      i === "BIN" ? Promise.resolve([]) : this.#p(e, a, o),
+      i === "CL" ? Promise.resolve([]) : this.#m(e, a, o)
+    ]);
+    return [...s, ...r];
+  }
+  async #p(e, o, n) {
+    const a = this.chain.contracts.clPositionManager;
+    if (a === void 0) return [];
+    const i = await this.#e.getLogs({
+      address: a,
+      event: Y[2],
+      args: { to: e },
+      fromBlock: o,
+      toBlock: "latest"
+    }), s = [...new Set(i.map((l) => l.args.id))], r = [];
+    for (const l of s) {
+      let c;
+      try {
+        c = await this.#e.readContract({ address: a, abi: Y, functionName: "ownerOf", args: [l] });
+      } catch {
+        continue;
+      }
+      if (!b(c, e)) continue;
+      const [d, p, m, u, h, y] = await this.#e.readContract({
+        address: a,
+        abi: Y,
+        functionName: "positions",
+        args: [l]
+      }), w = await this.#a(d, "CL", n);
+      if (w === null) continue;
+      const [[k, T], [B, g], M, q] = await Promise.all([
+        this.#e.readContract({ address: d.poolManager, abi: K, functionName: "getSlot0", args: [w.id] }),
+        this.#e.readContract({ address: d.poolManager, abi: _, functionName: "getFeeGrowthGlobals", args: [w.id] }),
+        this.#e.readContract({ address: d.poolManager, abi: _, functionName: "getPoolTickInfo", args: [w.id, p] }),
+        this.#e.readContract({ address: d.poolManager, abi: _, functionName: "getPoolTickInfo", args: [w.id, m] })
+      ]), D = U(k, p, m, u, !1), x = Ue({
+        liquidity: u,
+        tickLower: p,
+        tickUpper: m,
+        currentTick: T,
+        feeGrowthGlobal0X128: B,
+        feeGrowthGlobal1X128: g,
+        lower: M,
+        upper: q,
+        feeGrowthInside0LastX128: h,
+        feeGrowthInside1LastX128: y
+      });
+      r.push({
+        id: `cl:${l}`,
+        tokenId: l,
+        pool: w,
+        range: { type: "CL", tickLower: p, tickUpper: m },
+        liquidity: u,
+        amount0: D.amount0,
+        amount1: D.amount1,
+        feesOwed0: x.fees0,
+        feesOwed1: x.fees1,
+        inRange: T >= p && T < m,
+        source: "live"
+      });
+    }
+    return r;
+  }
+  async #m(e, o, n) {
+    const a = this.chain.contracts.binPositionManager;
+    if (a === void 0) return [];
+    const i = await this.#e.getLogs({
+      address: a,
+      event: W[2],
+      args: { to: e },
+      fromBlock: o,
+      toBlock: "latest"
+    }), s = [...new Set(i.flatMap((c) => c.args.ids ?? []))], r = /* @__PURE__ */ new Map();
+    for (const c of s) {
+      const d = await this.#e.readContract({ address: a, abi: W, functionName: "balanceOf", args: [e, c] });
+      if (d === 0n) continue;
+      const [p, m] = await this.#e.readContract({ address: a, abi: W, functionName: "positions", args: [c] }), u = oe(p), h = r.get(u) ?? { key: p, bins: [] };
+      h.bins.push({ binId: m, shares: d }), r.set(u, h);
+    }
+    const l = [];
+    for (const [c, { key: d, bins: p }] of r) {
+      const m = await this.#a(d, "BIN", n);
+      if (m === null) continue;
+      const [u] = await this.#e.readContract({ address: d.poolManager, abi: X, functionName: "getSlot0", args: [c] });
+      let h = 0n, y = 0n, w = 0n;
+      const k = [...p].sort((g, M) => g.binId - M.binId);
+      for (const g of k) {
+        const [M, q, , D] = await this.#e.readContract({
+          address: d.poolManager,
+          abi: pe,
+          functionName: "getBin",
+          args: [c, g.binId]
+        }), x = re({ shares: g.shares, totalShares: D, reserveX: M, reserveY: q });
+        h += x.amount0, y += x.amount1, w += g.shares;
+      }
+      const T = k[0], B = k[k.length - 1];
+      l.push({
+        id: `bin:${c}`,
+        pool: m,
+        range: { type: "BIN", activeIdDesired: u, binIdLower: T.binId, binIdUpper: B.binId, idSlippage: 0 },
+        liquidity: w,
+        amount0: h,
+        amount1: y,
+        /* Bin fees compound into the bins' reserves; they are inside amount0/amount1, never a separate figure. */
+        feesOwed0: 0n,
+        feesOwed1: 0n,
+        binAmounts: k.map((g) => ({ binId: g.binId, amount: g.shares })),
+        inRange: k.some((g) => g.binId === u),
+        source: "live"
+      });
+    }
+    return l;
+  }
+  /**
+   * The `PoolInfo` for a position's key: the configured one when the pool is
+   * listed, else one built from the key with both tokens read off their
+   * contracts. `null` when `only` names a different pool.
+   */
+  async #a(e, o, n) {
+    const a = oe(e);
+    if (n !== void 0) return n.id.toLowerCase() === a.toLowerCase() ? n : null;
+    const i = this.#t.pools.find((c) => c.id.toLowerCase() === a.toLowerCase());
+    if (i !== void 0) return i;
+    const [s, r] = await Promise.all([this.getToken(e.currency0), this.getToken(e.currency1)]);
+    if (s === null || r === null) return null;
+    const l = o === "CL" ? { tickSpacing: Ne(e).tickSpacing } : { binStep: te(e).binStep };
+    return { id: a, key: e, poolType: o, token0: s, token1: r, lpFeePips: e.fee, hooks: e.hooks, ...l };
+  }
+  /**
+   * What withdrawing `percentBps` of a position returns as PRINCIPAL, rounded
+   * down as the pool rounds a burn. A CL decrease also pays out the position's
+   * uncollected fees (`feesOwed0/1` on the position); they are not in these
+   * figures because the position manager's minimum-out check is on the
+   * principal alone, and a floor that counted fees could revert an honest
+   * withdrawal.
+   */
+  async quoteRemoveLiquidity(e, o) {
+    const n = this.#n.quoteRemoveLiquidity;
+    if (n !== void 0) return n(e, o);
+    if (!Number.isInteger(o) || o <= 0 || o > 1e4)
+      throw new RangeError(`[@latchprotocol/widgets] percentBps must be an integer in (0, 10000]: ${o}`);
+    const { pool: a } = e;
+    if (e.range.type === "CL") {
+      const l = await this.getPoolState(a), c = e.liquidity * BigInt(o) / 10000n, d = U(l.sqrtPriceX96, e.range.tickLower, e.range.tickUpper, c, !1);
+      return { position: e, percentBps: o, amount0: d.amount0, amount1: d.amount1, source: "live" };
+    }
+    const i = e.binAmounts ?? [];
+    let s = 0n, r = 0n;
+    for (const l of i) {
+      const [c, d, , p] = await this.#e.readContract({
+        address: a.key.poolManager,
+        abi: pe,
+        functionName: "getBin",
+        args: [a.id, l.binId]
+      }), m = re({ shares: l.amount * BigInt(o) / 10000n, totalShares: p, reserveX: c, reserveY: d });
+      s += m.amount0, r += m.amount1;
+    }
+    return { position: e, percentBps: o, amount0: s, amount1: r, source: "live" };
+  }
+  async buildRemoveLiquidity(e) {
+    const o = await this.getAccount();
+    if (o === null) throw new E("remove liquidity");
+    const { position: n } = e;
+    if (n.range.type === "CL") {
+      const r = L(
+        this.chain,
+        "clPositionManager",
+        "decrease a concentrated-liquidity position"
+      );
+      if (n.tokenId === void 0)
+        throw new f(
+          "buildRemoveLiquidity",
+          "a CL position must carry its ERC-721 tokenId"
+        );
+      const l = n.liquidity * BigInt(e.percentBps) / 10000n, c = vt({
+        positionManager: r,
+        poolKey: n.pool.key,
+        tokenId: n.tokenId,
+        liquidity: l,
+        amount0Min: e.amount0Min,
+        amount1Min: e.amount1Min,
+        recipient: e.recipient,
+        owner: o,
+        deadline: e.deadline,
+        ...e.hookData ? { hookData: e.hookData } : {}
+      });
+      return {
+        to: c.to,
+        data: c.data,
+        value: c.value,
+        summary: `Remove ${e.percentBps / 100}% of position #${n.tokenId}`,
+        source: "live"
+      };
+    }
+    const a = L(
+      this.chain,
+      "binPositionManager",
+      "remove liquidity from a bin pool"
+    ), i = n.binAmounts;
+    if (i === void 0 || i.length === 0)
+      throw new f(
+        "buildRemoveLiquidity",
+        "a bin burn needs the per-bin share amounts held by the position"
+      );
+    const s = It({
+      positionManager: a,
+      poolKey: n.pool.key,
+      amount0Min: e.amount0Min,
+      amount1Min: e.amount1Min,
+      ids: i.map((r) => r.binId),
+      amounts: i.map(
+        (r) => r.amount * BigInt(e.percentBps) / 10000n
+      ),
+      from: o,
+      recipient: e.recipient,
+      deadline: e.deadline,
+      ...e.hookData ? { hookData: e.hookData } : {}
+    });
+    return {
+      to: s.to,
+      data: s.data,
+      value: s.value,
+      summary: `Remove ${e.percentBps / 100}% of a bin position`,
+      source: "live"
+    };
+  }
+  /**
+   * Requires at least one launch guard. A chain with neither is "no launchpad
+   * here", signalled the way every missing contract is: `ChainConfigError`
+   * naming `launchGuardHook`, which `isLaunchpadNotConfigured` recognises.
+   */
+  #s(e) {
+    const { launchGuardHook: o, binLaunchGuardHook: n } = this.chain.contracts;
+    o === void 0 && n === void 0 && L(this.chain, "launchGuardHook", e);
+  }
+  /**
+   * Every configured pool whose key names one of the chain's launch guards:
+   * CL pools naming `launchGuardHook`, Bin pools naming `binLaunchGuardHook`.
+   *
+   * There is no on-chain enumeration of launches any more than there is of
+   * pools, so the candidate set is the pool list the host supplied. Throws
+   * `ChainConfigError` when no guard address is configured, which is how a
+   * caller distinguishes "no launchpad on this chain" from "no launches yet".
+   */
+  async listLaunches() {
+    this.#s("read a launch schedule");
+    const e = this.#t.pools.filter((n) => this.#o(n) !== null);
+    return (await Promise.all(e.map((n) => this.#i(n)))).filter((n) => n !== null);
+  }
+  async getLaunch(e) {
+    this.#s("read a launch schedule");
+    const o = this.#t.pools.find((n) => n.id === e);
+    if (o === void 0)
+      throw new f(
+        "getLaunch",
+        `pool ${e} is not in the configured pool list. The singleton has no pool enumeration, so the widget can only read pools the host declared.`
+      );
+    return this.#o(o) === null ? null : this.#i(o);
+  }
+  /**
+   * The pools a `LaunchpadKitV2` launch opened for `token`, read from the kit's
+   * `legsOf(token)` and then from the guards, in leg order.
+   *
+   * Every leg's pool must be in the host's pool list — the kit knows the ids,
+   * not the keys, and a pool the host has not declared cannot be quoted or
+   * swapped through anyway. A missing one is an error naming the id, not a
+   * shorter list.
+   */
+  async getLaunchesForToken(e) {
+    const o = L(this.chain, "launchpadKitV2", "look a launch up by its token"), n = await this.#e.readContract({
+      address: o,
+      abi: Se,
+      functionName: "legsOf",
+      args: [e]
+    });
+    if (n.length === 0) return [];
+    const a = n.filter((r) => this.#t.pools.every((l) => l.id !== r));
+    if (a.length > 0)
+      throw new f(
+        "getLaunchesForToken",
+        `the kit lists ${n.length} pool(s) for ${e} but ${a.length} of them (${a.join(", ")}) are not in the configured pool list. Declare them (the pool manager's Initialize log carries the key) so the widget can read and route through them.`
+      );
+    const i = n.filter((r) => {
+      const l = this.#t.pools.find((c) => c.id === r);
+      return this.#o(l) === null;
+    });
+    if (i.length > 0)
+      throw new f(
+        "getLaunchesForToken",
+        `${i.length} of the kit's pools for ${e} (${i.join(", ")}) name a launch guard this chain config does not declare. Set \`contracts.launchGuardHook\` (CL) and \`contracts.binLaunchGuardHook\` (Bin) to the kit's guards; a launch cannot be shown with a leg missing.`
+      );
+    return await Promise.all(
+      n.map(async (r) => {
+        const l = this.#t.pools.find((d) => d.id === r), c = await this.#i(l);
+        if (c === null)
+          throw new f(
+            "getLaunchesForToken",
+            `the kit lists pool ${r} for ${e} but its guard has no launch record for it`
+          );
+        return c;
+      })
+    );
+  }
+  /**
+   * Which generation a launch hook is, by configuration first, then the SDK
+   * address book, then the hook's own `CLOCK_MODE()` (a revert means the
+   * block-numbered build). A transport failure throws; it is never a revert.
+   */
+  async #r(e, o = "CL") {
+    if (o === "CL") {
+      const i = this.chain.contracts.launchGuardHookClock;
+      if (i !== void 0) return i;
+    }
+    const n = $e(this.chain.chainId);
+    if (o === "CL" && n?.launchGuardHook && b(n.launchGuardHook, e)) {
+      const i = n.durationClocks.launchGuardHook;
+      if (i !== null) return i;
+    }
+    const a = n?.launchpadV2;
+    if (a !== void 0) {
+      const i = o === "CL" ? a.clLaunchGuardHook : a.binLaunchGuardHook;
+      if (i !== null && b(i, e)) return "timestamp";
+    }
+    try {
+      const { data: i } = await this.#e.call({ to: e, data: Pe });
+      if (i === void 0 || i === "0x") return "contract-block";
+      const [s] = Le([{ type: "string" }], i);
+      if (s === Be) return "timestamp";
+      throw new f("getLaunch", `hook ${e} reports an unknown CLOCK_MODE "${s}"`);
+    } catch (i) {
+      if (i instanceof J && i.walk((s) => s instanceof Z) !== null)
+        return "contract-block";
+      throw i;
+    }
+  }
+  async #i(e) {
+    const o = this.#o(e);
+    if (o === null) return null;
+    const n = o.hook, a = await this.#r(n, o.poolType);
+    if (o.poolType === "BIN" && a !== "timestamp")
+      throw new f(
+        "getLaunch",
+        `BinLaunchGuardHook ${n} answers as a block-numbered build; no such build exists, so this is not a Bin launch guard.`
+      );
+    const i = o.poolType === "CL" ? ae(a) : ee, s = await this.#e.readContract({
+      address: n,
+      abi: i,
+      functionName: "getLaunch",
+      args: [e.id]
+    }), r = Ke(s, a);
+    if (!Xe(r)) return null;
+    const [l, c] = await Promise.all([
+      this.#e.readContract({
+        address: n,
+        abi: i,
+        functionName: "currentFee",
+        args: [e.id]
+      }),
+      /* "Now" on the HOOK's clock. The timestamp build compares with
+         block.timestamp. The block-numbered build compares with the EVM's
+         block.number, which on an Arbitrum chain (Robinhood, 4663) is
+         Ethereum's block number while the RPC head is the L2 block; against
+         the RPC head every unopened launch rendered as settled. */
+      xe(this.#e, this.chain.chainId)
+    ]), d = a === "timestamp" ? c.timestamp : c.contractBlockNumber, [p, m] = r.launchTokenIsCurrency0 ? [e.token0, e.token1] : [e.token1, e.token0];
+    return {
+      poolId: e.id,
+      pool: e,
+      hook: n,
+      launchToken: p,
+      quoteToken: m,
+      guard: r,
+      currentFeePips: Number(l),
+      readAt: d,
+      source: "live"
+    };
+  }
+  async sendTransaction(e) {
+    const o = this.#t.wallet;
+    if (o === void 0) throw new E("send a transaction");
+    return o.sendTransaction({
+      to: e.to,
+      data: e.data,
+      value: e.value
+    });
+  }
+  /**
+   * The clock the next block will carry, as closely as the RPC can say: the
+   * later of the PENDING block's timestamp (anvil and geth-style nodes compute
+   * the next block's; an RPC without one refuses or echoes the latest) and the
+   * latest block's. See `nextBlockClock` for why the pending read matters.
+   */
+  async getBlockTimestamp() {
+    const [e, o] = await Promise.allSettled([
+      this.#e.getBlock({ blockTag: "pending" }),
+      this.#e.getBlock({ blockTag: "latest" })
+    ]), n = Ye(
+      e.status === "fulfilled" ? e.value.timestamp : null,
+      o.status === "fulfilled" ? o.value.timestamp : null
+    );
+    if (n === null) throw o.status === "rejected" ? o.reason : new Error("no block timestamp could be read");
+    return n;
+  }
+  async waitForTransaction(e) {
+    const o = await this.#e.waitForTransactionReceipt({ hash: e });
+    return {
+      hash: e,
+      status: o.status === "success" ? "success" : "reverted",
+      blockNumber: o.blockNumber,
+      source: "live"
+    };
+  }
+}
+function Rt(t) {
+  return new Ct(t);
+}
+function Ft(t, e, o, n = {}) {
+  const a = n.native ?? me, i = n.lp ?? {};
+  return P(
+    () => Ve(t, e, o, { native: a, lp: i }),
+    [t, e, o, a.symbol, a.decimals, i.lpLocker, i.binLpLocker, i.poolType, i.lpLockerFromBlock, (i.lpLockerTokenIds ?? []).join(",")],
+    { enabled: He(e, i), refetchIntervalMs: n.refetchIntervalMs ?? 6e4 }
+  );
+}
+function Gt(t, e, o, n = {}) {
+  const a = n.native ?? me, i = n.lp ?? {}, s = !!i.lpLocker || !!i.binLpLocker;
+  return P(
+    () => je(t, e, o, { native: a, lp: i }),
+    [t, e, o, a.symbol, a.decimals, i.lpLocker, i.binLpLocker, i.lpLockerFromBlock, (i.lpLockerTokenIds ?? []).join(",")],
+    { enabled: e !== null || s, refetchIntervalMs: n.refetchIntervalMs ?? 6e4 }
+  );
+}
+function qt(t, e) {
+  const [o, n] = he(() => Date.now());
+  return Ze(() => {
+    if (t === null) return;
+    const a = setInterval(() => n(Date.now()), 1e3);
+    return () => clearInterval(a);
+  }, [t]), t === null || e === null ? null : We(t, e, o);
+}
+function I(t) {
+  return t.status === "read" ? t.sources ?? [] : t.status === "error" && t.source ? [t.source] : [];
+}
+function v(t, e, o, n, a) {
+  return { key: t, label: e, headline: o.headline, detail: o.detail, tone: o.tone, provenance: n.map((i) => ut(i, a.readAt)), sources: n };
+}
+const ge = {
+  "launch-leg": "a Kit v2 launch leg",
+  "lp-locker": "an LP-locker lock",
+  "position-lock": "a LatchPositionLock time lock",
+  given: "this page's pool list"
+};
+function ve(t) {
+  return t.length <= 1 ? t[0] ?? "" : `${t.slice(0, -1).join(", ")} and ${t[t.length - 1]}`;
+}
+const Tt = (t, e) => t[e.toLowerCase()] ?? `${e.slice(0, 6)}…${e.slice(-4)}`;
+function Mt(t, e, o) {
+  const n = [
+    {
+      ...v("liquidity", "Liquidity locks", at(t.liquidity, t.kind), I(t.liquidity), e),
+      share: t.liquidity.status !== "read" || !t.liquidity.measurable ? null : t.kind === "Bin" ? ce([{ key: "permanent", label: "Locked permanently (LP locker)", bps: t.liquidity.lockedActiveBps }], "of the active bin") : ce(
+        [
+          { key: "permanent", label: "Locked permanently (LP locker)", bps: t.liquidity.permanentActiveBps },
+          { key: "time", label: "Time-locked until a date", bps: t.liquidity.timeLockedActiveBps }
+        ],
+        "of active liquidity"
+      )
+    },
+    v("lp-fee", "LP fee", st(t.lpFee), t.lpFee.kind === "error" ? [] : t.lpFee.source === null ? [] : [t.lpFee.source], e),
+    v("protocol-fee", "Protocol fee", rt(t.protocolFee), I(t.protocolFee), e)
+  ];
+  return t.tax.status !== "not-a-launch-pool" && n.push(v("tax", "Creator tax", ye(t.tax, e.readAt.chainNow), I(t.tax), e)), n.push(v("registry", "Hook in LatchRegistry", ct(t.registry), t.registry.status === "no-hook" ? [] : I(t.registry), e)), {
+    poolId: t.poolId,
+    title: `${e.symbol} / ${Tt(o, t.pairedWith)} · ${t.kind} pool`,
+    foundBy: `Found through ${ve(t.origins.map((a) => ge[a]))}.`,
+    rows: n
+  };
+}
+function Nt(t) {
+  const e = t.launch;
+  if (e.status === "not-configured")
+    return v("tax", "Creator tax", { headline: "Coming soon", detail: "Latch launches are coming soon on this chain, so there is no creator tax to read.", tone: "missing" }, [], t);
+  if (e.status === "error")
+    return v("tax", "Creator tax", { headline: "Could not be read", detail: `The launch read failed: ${e.message}.`, tone: "error" }, I(e), t);
+  if (e.launch === null)
+    return v("tax", "Creator tax", { headline: "Not a Latch launch", detail: "LaunchpadKitV2 has no launch for this token, so no Latch launch guard takes a creator tax on it.", tone: "neutral" }, I(e), t);
+  const o = t.pools.filter((s) => s.origins.includes("launch-leg") && s.tax.status !== "not-a-launch-pool");
+  if (o.length === 0)
+    return v("tax", "Creator tax", { headline: "Could not be read", detail: "No launch pool of this token could be described, so its tax was not read.", tone: "error" }, I(e), t);
+  const n = o.map((s) => ye(s.tax, t.readAt.chainNow)), a = o.flatMap((s) => I(s.tax)).filter((s, r, l) => l.findIndex((c) => c.address.toLowerCase() === s.address.toLowerCase()) === r), i = n[0];
+  return n.every((s) => s.headline === i.headline && s.detail === i.detail) ? v("tax", "Creator tax", o.length === 1 ? i : { ...i, detail: `${i.detail ?? ""} Same on all ${o.length} launch pools.`.trim() }, a, t) : v("tax", "Creator tax", { headline: "Differs by pool", detail: "Each launch pool below carries its own terms.", tone: n.some((s) => s.tone === "caution") ? "caution" : "neutral" }, a, t);
+}
+function Ut(t, e = {}) {
+  const o = t.discovery.searched.map((i) => ge[i]), n = `Pools listed are those found through ${o.length === 0 ? "no source yet: these reads are coming soon on this chain" : ve(o)}${t.discovery.truncated ? ", and only the first of them were read" : ""}${t.discovery.positionLocksTruncated ? " (newest position locks only)" : ""}. A pool of this token that no Latch launch or lock knows about is not listed.`, a = t.readAt.fromBlock === t.readAt.toBlock ? `block ${t.readAt.fromBlock.toLocaleString("en-US")}` : `blocks ${t.readAt.fromBlock.toLocaleString("en-US")}–${t.readAt.toBlock.toLocaleString("en-US")}`;
+  return {
+    summary: it(t),
+    launch: v("launch", "Latch launch", ot(t.launch, t.readAt), I(t.launch), t),
+    tokenLocks: {
+      ...v("token-locks", "Token locks & vesting", nt(t.tokenLocks, t.symbol, t.decimals), I(t.tokenLocks), t),
+      share: t.tokenLocks.status === "read" && t.tokenLocks.lockCount > 0 ? Qe(t.tokenLocks) : null
+    },
+    creatorTax: Nt(t),
+    pools: t.pools.map((i) => Mt(i, t, e)),
+    failedPools: t.failedPools.map((i) => `${i.kind} pool ${i.poolId.slice(0, 10)}… could not be described: ${i.message}.`),
+    discoveryNote: n,
+    readAtNote: `Read from chain at ${a}; expiries judged against the chain's clock. Token units, never priced. A registry listing is what the registry records, not an audit.`
+  };
+}
+async function St(t, e) {
+  const o = await lt(t, {
+    token: e.token,
+    contracts: e.contracts,
+    ...e.pools !== void 0 ? { pools: e.pools } : {},
+    ...e.lpLockerTokenIds !== void 0 ? { lpLockerTokenIds: e.lpLockerTokenIds } : {},
+    ...e.native !== void 0 ? { native: e.native } : {}
+  }), n = [...new Set(o.pools.map((r) => r.pairedWith.toLowerCase()))], a = e.native?.symbol ?? "ETH", i = await Promise.all(n.map((r) => r === Ie ? Promise.resolve({ symbol: a }) : De(t, r).catch(() => null))), s = {};
+  return n.forEach((r, l) => {
+    const c = i[l];
+    c && (s[r] = c.symbol);
+  }), { trust: o, symbols: s };
+}
+function Kt(t, e, o = {}) {
+  const n = e.contracts, a = n === null ? "none" : Object.entries(n).map(([i, s]) => `${i}:${String(s ?? "")}`).sort().join("|");
+  return P(
+    () => St(t, { ...e, contracts: n }),
+    [
+      t,
+      e.token.toLowerCase(),
+      a,
+      (e.pools ?? []).map((i) => `${i.kind}${i.poolId}`).join(","),
+      (e.lpLockerTokenIds ?? []).join(","),
+      e.native?.symbol,
+      e.native?.decimals
+    ],
+    { enabled: n !== null, refetchIntervalMs: o.refetchIntervalMs ?? 6e4 }
+  );
+}
+function Xt(t, e) {
+  const o = t.trim().replace(/_/g, "");
+  if (!/^\d+(\.\d+)?$/.test(o) || (o.split(".")[1] ?? "").length > e) return null;
+  try {
+    return Ae(o, e);
+  } catch {
+    return null;
+  }
+}
+function Yt(t) {
+  const e = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})$/.exec(t.trim());
+  if (e === null) return null;
+  const o = Date.UTC(Number(e[1]), Number(e[2]) - 1, Number(e[3]), Number(e[4]), Number(e[5]));
+  return Number.isFinite(o) ? BigInt(Math.floor(o / 1e3)) : null;
+}
+function Wt(t) {
+  return new Date(Number(t) * 1e3).toISOString().slice(0, 16);
+}
+function Ht(t) {
+  const e = t.trim();
+  return /^\d+$/.test(e) ? BigInt(e) * 86400n : null;
+}
+function Vt(t, e) {
+  return t === "timelock" ? e.unlockAt === null ? null : { start: e.unlockAt, cliff: e.unlockAt, end: e.unlockAt } : e.start === null || e.cliffDays === null || e.durationDays === null ? null : { start: e.start, cliff: e.start + e.cliffDays, end: e.start + e.durationDays };
+}
+function H(t, e) {
+  if (t === 0n) return "0";
+  const o = 10n ** BigInt(e), n = t / o, a = (t % o).toString().padStart(e, "0").replace(/0+$/, "");
+  return a === "" ? n.toLocaleString("en-US") : `${n.toLocaleString("en-US")}.${a}`;
+}
+function jt(t, e) {
+  const o = `${H(t.feeWei, e.decimals)} ${e.symbol} per lock`, n = t.pendingFee, a = n !== null && n.feeWei > t.feeWei, i = a ? n.feeWei : t.feeWei, s = n === null ? null : `${n.feeWei > t.feeWei ? "An increase" : "A change"} to ${H(n.feeWei, e.decimals)} ${e.symbol} applies from ${new Date(Number(n.effectiveAt) * 1e3).toISOString().replace("T", " ").slice(0, 16)} UTC.`;
+  return {
+    fee: o,
+    sends: `${H(i, e.decimals)} ${e.symbol}`,
+    pending: s,
+    note: `Charged by the lock contract itself and paid only to its fee recipient ${t.recipient.slice(0, 6)}…${t.recipient.slice(-4)}.${a ? " The transaction sends the announced higher fee in case it applies before it mines; the contract refunds any surplus in the same call." : ""}`
+  };
+}
+function Qt(t) {
+  const e = [];
+  return t.approved || e.push({ key: "approve", label: `Approve LatchPositionLock to move position #${t.tokenId} (this NFT only)` }), e.push({ key: "lock", label: `Lock position #${t.tokenId} until ${new Date(Number(t.unlockAt) * 1e3).toISOString().replace("T", " ").slice(0, 16)} UTC, paying the fee` }), e;
+}
+function zt(t) {
+  const e = [];
+  return !t.native && t.allowance < t.amount && e.push({ key: "approve", label: `Approve LatchTokenLock for exactly ${t.amountText} ${t.symbol}` }), e.push({ key: "lock", label: `Lock ${t.amountText} ${t.symbol}, paying the fee${t.native ? " (the amount is sent with it)" : ""}` }), e;
+}
+const R = (t, e) => t != null && e !== null && e !== void 0 && t.toLowerCase() === e.toLowerCase();
+function Jt(t, e, o) {
+  if (t.withdrawn) return [];
+  const n = ["collect"];
+  return R(t.owner, e) && (n.push("extend"), o >= t.unlockAt && n.push("withdraw")), R(t.pendingOwner, e) && n.push("accept"), n;
+}
+function Zt(t, e) {
+  const o = [];
+  return R(t.beneficiary, e) && t.claimable > 0n && o.push("claim"), R(t.pendingBeneficiary, e) && o.push("accept"), o;
+}
+const en = {
+  collect: "Collect fees",
+  extend: "Extend",
+  withdraw: "Withdraw",
+  accept: "Accept lock"
+}, tn = {
+  claim: "Claim vested",
+  accept: "Accept lock"
+};
+function nn(t) {
+  const e = Je();
+  return tt(() => {
+    if (t !== void 0) return t;
+    const o = e?.adapter;
+    return o === void 0 || o.isMock ? null : {
+      getAccount: () => o.getAccount(),
+      sendTransaction: (n) => o.sendTransaction({ ...n, summary: "Latch lock", source: "live" })
+    };
+  }, [t, e?.adapter]);
+}
+function on(t) {
+  return P(() => t === null ? Promise.resolve(null) : t.getAccount(), [t], { refetchIntervalMs: 4e3 });
+}
+function an(t, e) {
+  return P(
+    async () => {
+      const [o, n] = await Promise.all([
+        e.positionLock === null ? Promise.resolve(null) : le(t, e.positionLock),
+        e.tokenLock === null ? Promise.resolve(null) : le(t, e.tokenLock)
+      ]);
+      return { position: o, token: n };
+    },
+    [t, e.positionLock, e.tokenLock],
+    { enabled: e.positionLock !== null || e.tokenLock !== null, refetchIntervalMs: 6e4 }
+  );
+}
+function sn(t, e, o) {
+  return P(
+    async () => {
+      const n = o, [a, i, s] = await Promise.all([
+        dt(t),
+        e.positionLock === null ? Promise.resolve([]) : pt(t, e.positionLock, n),
+        e.tokenLock === null ? Promise.resolve({ locks: [] }) : mt(t, e.tokenLock, n)
+      ]);
+      return { positions: i, tokens: s.locks, now: a };
+    },
+    [t, e.positionLock, e.tokenLock, o],
+    { enabled: o !== null && (e.positionLock !== null || e.tokenLock !== null), refetchIntervalMs: 6e4 }
+  );
+}
+class V extends Error {
+  hash;
+  constructor(e) {
+    super(`The transaction ${e.slice(0, 10)}… was mined and reverted.`), this.name = "TransactionRevertedError", this.hash = e;
+  }
+}
+async function rn(t, e, o, n) {
+  await t.call({ account: o, to: n.to, data: n.data, value: n.value });
+  const a = await e.sendTransaction({ to: n.to, data: n.data, value: n.value });
+  if ((await t.waitForTransactionReceipt({ hash: a })).status !== "success") throw new V(a);
+  return a;
+}
+function cn(t, e, o, n) {
+  const [a, i] = he({ k: "idle" }), s = et(!1), r = ue(
+    async (c) => {
+      if (s.current) return;
+      const d = c.map((u) => u.label);
+      if (e === null || o === null) {
+        i({ k: "failed", labels: d, active: 0, message: "Connect a wallet first." });
+        return;
+      }
+      s.current = !0;
+      const p = [];
+      let m = 0;
+      try {
+        for (; m < c.length; m++) {
+          i({ k: "running", labels: d, active: m, phase: "simulating" });
+          const u = await c[m].build();
+          await t.call({ account: o, to: u.to, data: u.data, value: u.value }), i({ k: "running", labels: d, active: m, phase: "signing" });
+          const h = await e.sendTransaction({ to: u.to, data: u.data, value: u.value });
+          if (i({ k: "running", labels: d, active: m, phase: "confirming" }), (await t.waitForTransactionReceipt({ hash: h })).status !== "success") throw new V(h);
+          p.push(h);
+        }
+        i({ k: "done", labels: d, hashes: p }), n?.();
+      } catch (u) {
+        i({ k: "failed", labels: d, active: m, message: u instanceof V ? u.message : ze(u, "transaction") });
+      } finally {
+        s.current = !1;
+      }
+    },
+    [t, e, o, n]
+  ), l = ue(() => i({ k: "idle" }), []);
+  return { state: a, run: r, reset: l };
+}
+export {
+  sn as A,
+  Ft as B,
+  Gt as C,
+  Kt as D,
+  Et as N,
+  en as P,
+  tn as T,
+  V as a,
+  Lt as b,
+  It as c,
+  vt as d,
+  gt as e,
+  ht as f,
+  Rt as g,
+  St as h,
+  _t as i,
+  jt as j,
+  Xt as k,
+  Vt as l,
+  Yt as m,
+  Qt as n,
+  zt as o,
+  Ht as p,
+  Jt as q,
+  Zt as r,
+  rn as s,
+  Wt as t,
+  Ut as u,
+  qt as v,
+  on as w,
+  an as x,
+  cn as y,
+  nn as z
+};
+//# sourceMappingURL=useLocker-D1c_NTk-.js.map