@pafi-dev/trading 0.9.0 → 0.10.0

package/dist/index.js

@@ -3,6 +3,7 @@ import { getAddress } from "viem";
 import {
   buildPerpDepositWithGasDeduction,
   buildPerpDepositViaRelay,
+  buildErc20TransferUserOp,
   ORDERLY_RELAY_ABI,
   getContractAddresses,
   UNIVERSAL_ROUTER_ADDRESSES,
@@ -13,7 +14,8 @@ import {
   ValidationError,
   computeAccountId,
   quoteOperatorFeePt,
-  quoteOperatorFeeUsdt
+  quoteOperatorFeeUsdt,
+  quoteOperatorFeeForTransfer
 } from "@pafi-dev/core";
 
 // src/quoting/routes.ts
@@ -1108,6 +1110,114 @@ var TradingHandlers = class {
       feeRecipient: pafiFeeRecipient
     };
   }
+  // =========================================================================
+  // POST /erc20-transfer  — gasless ERC-20 send (USDC/USDT/active-PT)
+  // =========================================================================
+  /**
+   * Build a sponsored ERC-20 transfer UserOp pair (sponsored + fallback).
+   *
+   * Sponsored variant: `[token.transfer(PAFI, fee), token.transfer(recipient, amount)]`.
+   * Fallback variant: `[token.transfer(recipient, amount)]` (user pays ETH).
+   *
+   * Both calls hit the SAME token contract — fee currency equals the
+   * token being sent, so the user needs only ONE token (≥ `amount + fee`)
+   * to complete a gasless send.
+   *
+   * Allowlist enforced HERE (client-side fail-fast) **and** server-side
+   * by sponsor-relayer's IntentValidator:
+   *   - USDC (`getContractAddresses(chainId).usdc`)
+   *   - USDT (`getContractAddresses(chainId).usdt`)
+   *   - active PointToken (caller responsibility to check
+   *     `IssuerRegistry.isActiveByPointToken` if not stable)
+   *
+   * Recipient rejected when equal to `pafiFeeRecipient` (self-fee abuse)
+   * or `0x0` (use the burn scenario for that).
+   *
+   * See `docs/SPONSORED_ERC20_TRANSFER_SPEC.md` for the full call
+   * pattern, error codes, and edge cases.
+   */
+  async handleErc20Transfer(authenticatedAddress, request) {
+    if (getAddress(authenticatedAddress) !== getAddress(request.userAddress)) {
+      throw new ValidationError(
+        "USER_ADDRESS_MISMATCH",
+        `handleErc20Transfer: authenticatedAddress (${authenticatedAddress}) does not match request.userAddress (${request.userAddress})`
+      );
+    }
+    if (request.chainId !== this.chainId) {
+      throw new ValidationError(
+        "UNSUPPORTED_CHAIN_ID",
+        `handleErc20Transfer: unsupported chainId ${request.chainId}`,
+        { requested: request.chainId, supported: this.chainId }
+      );
+    }
+    if (request.amount <= 0n) {
+      throw new ValidationError(
+        "ZERO_AMOUNT",
+        "handleErc20Transfer: amount must be positive"
+      );
+    }
+    const userAddress = getAddress(request.userAddress);
+    const tokenAddress = getAddress(request.tokenAddress);
+    const recipient = getAddress(request.recipient);
+    const addrs = getContractAddresses(request.chainId);
+    const pafiFeeRecipient = addrs.pafiFeeRecipient;
+    if (recipient.toLowerCase() === pafiFeeRecipient.toLowerCase()) {
+      throw new ValidationError(
+        "SELF_FEE_ABUSE",
+        "handleErc20Transfer: recipient cannot be the PAFI fee recipient",
+        { recipient, pafiFeeRecipient }
+      );
+    }
+    if (recipient === "0x0000000000000000000000000000000000000000") {
+      throw new ValidationError(
+        "USE_BURN_SCENARIO",
+        "handleErc20Transfer: recipient cannot be the zero address \u2014 use the burn scenario instead"
+      );
+    }
+    const isStable = addrs.usdc && tokenAddress.toLowerCase() === addrs.usdc.toLowerCase() || tokenAddress.toLowerCase() === addrs.usdt.toLowerCase();
+    let feeAmount;
+    if (request.feeAmount !== void 0) {
+      feeAmount = request.feeAmount > 0n ? request.feeAmount : 0n;
+    } else {
+      feeAmount = await quoteOperatorFeeForTransfer({
+        provider: this.provider,
+        chainId: request.chainId,
+        tokenAddress
+      });
+    }
+    if (feeAmount > 0n && feeAmount >= request.amount) {
+      throw new ValidationError(
+        "INVALID_AMOUNT",
+        `handleErc20Transfer: fee (${feeAmount}) must be strictly less than amount (${request.amount})`,
+        { feeAmount, amount: request.amount }
+      );
+    }
+    const userOp = buildErc20TransferUserOp({
+      userAddress,
+      aaNonce: request.aaNonce,
+      tokenAddress,
+      recipient,
+      amount: request.amount,
+      feeAmount: feeAmount > 0n ? feeAmount : void 0,
+      feeRecipient: feeAmount > 0n ? pafiFeeRecipient : void 0
+    });
+    const userOpFallback = feeAmount > 0n ? buildErc20TransferUserOp({
+      userAddress,
+      aaNonce: request.aaNonce,
+      tokenAddress,
+      recipient,
+      amount: request.amount
+      // No feeAmount → 1-call variant (transfer only).
+    }) : void 0;
+    void isStable;
+    return {
+      userOp,
+      userOpFallback,
+      feeAmountUsed: feeAmount,
+      feeRecipient: pafiFeeRecipient,
+      tokenAddress
+    };
+  }
 };
 function isPlaceholderAddress(addr) {
   return /^0x0{36}[0-9a-fA-F]{4}$/i.test(addr);
@@ -1521,13 +1631,1922 @@ async function perpDepositDirect(params) {
     relayAddress
   };
 }
+
+// src/direct/transferDirect.ts
+import {
+  buildErc20TransferUserOp as buildErc20TransferUserOp2,
+  getContractAddresses as getContractAddresses5,
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress4,
+  detectDelegateImpl as detectDelegateImpl4,
+  BATCH_EXECUTOR_7702_IMPL as BATCH_EXECUTOR_7702_IMPL4,
+  SIMPLE_7702_IMPL_BASE_MAINNET as SIMPLE_7702_IMPL_BASE_MAINNET4
+} from "@pafi-dev/core";
+
+// src/direct/addLiquidityDirect.ts
+import {
+  decodeEventLog
+} from "viem";
+import {
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress5,
+  buildPartialUserOperation as buildPartialUserOperation2,
+  computeV3PoolAddress,
+  V3_FACTORY_ADDRESSES,
+  V3_POOL_INIT_CODE_HASH
+} from "@pafi-dev/core";
+
+// src/liquidity/abi/nonfungiblePositionManager.ts
+var nonfungiblePositionManagerAbi = [
+  // ─── Write methods ───────────────────────────────────────────────────────
+  {
+    type: "function",
+    name: "mint",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "token0", type: "address" },
+          { name: "token1", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "tickLower", type: "int24" },
+          { name: "tickUpper", type: "int24" },
+          { name: "amount0Desired", type: "uint256" },
+          { name: "amount1Desired", type: "uint256" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "liquidity", type: "uint128" },
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "increaseLiquidity",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "amount0Desired", type: "uint256" },
+          { name: "amount1Desired", type: "uint256" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "liquidity", type: "uint128" },
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "decreaseLiquidity",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "liquidity", type: "uint128" },
+          { name: "amount0Min", type: "uint256" },
+          { name: "amount1Min", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "collect",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenId", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "amount0Max", type: "uint128" },
+          { name: "amount1Max", type: "uint128" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amount0", type: "uint256" },
+      { name: "amount1", type: "uint256" }
+    ]
+  },
+  {
+    type: "function",
+    name: "burn",
+    stateMutability: "payable",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: []
+  },
+  // ─── Read methods ────────────────────────────────────────────────────────
+  // Returns the legacy V3 12-tuple. `readPosition` wraps this into a struct.
+  {
+    type: "function",
+    name: "positions",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [
+      { name: "nonce", type: "uint96" },
+      { name: "operator", type: "address" },
+      { name: "token0", type: "address" },
+      { name: "token1", type: "address" },
+      { name: "fee", type: "uint24" },
+      { name: "tickLower", type: "int24" },
+      { name: "tickUpper", type: "int24" },
+      { name: "liquidity", type: "uint128" },
+      { name: "feeGrowthInside0LastX128", type: "uint256" },
+      { name: "feeGrowthInside1LastX128", type: "uint256" },
+      { name: "tokensOwed0", type: "uint128" },
+      { name: "tokensOwed1", type: "uint128" }
+    ]
+  },
+  // Used by the ABI smoke test to verify NPM is wired to the expected
+  // PafiV3Factory.
+  {
+    type: "function",
+    name: "factory",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  // ─── Events (for receipt parsing) ────────────────────────────────────────
+  // Emitted from address(0) on mint; addLiquidityDirect parses this to
+  // extract the newly-minted tokenId.
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "IncreaseLiquidity",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "liquidity", type: "uint128", indexed: false },
+      { name: "amount0", type: "uint256", indexed: false },
+      { name: "amount1", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "DecreaseLiquidity",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "liquidity", type: "uint128", indexed: false },
+      { name: "amount0", type: "uint256", indexed: false },
+      { name: "amount1", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Collect",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "recipient", type: "address", indexed: false },
+      { name: "amount0", type: "uint256", indexed: false },
+      { name: "amount1", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/liquidity/abi/v3Pool.ts
+var v3PoolAbi = [
+  // Pool's underlying tokens. Read on-chain to verify the
+  // `computeV3PoolAddress(factory, token0, token1, fee)` derivation matches
+  // an already-deployed pool — and useful generally for consumers that
+  // discovered a pool by address (e.g. from a Transfer log) and need the
+  // tokens.
+  {
+    type: "function",
+    name: "token0",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    type: "function",
+    name: "token1",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  // (sqrtPriceX96, tick, observationIndex, observationCardinality,
+  //  observationCardinalityNext, feeProtocol, unlocked)
+  {
+    type: "function",
+    name: "slot0",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      { name: "sqrtPriceX96", type: "uint160" },
+      { name: "tick", type: "int24" },
+      { name: "observationIndex", type: "uint16" },
+      { name: "observationCardinality", type: "uint16" },
+      { name: "observationCardinalityNext", type: "uint16" },
+      { name: "feeProtocol", type: "uint8" },
+      { name: "unlocked", type: "bool" }
+    ]
+  },
+  {
+    type: "function",
+    name: "liquidity",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint128" }]
+  },
+  {
+    type: "function",
+    name: "tickSpacing",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "int24" }]
+  },
+  {
+    type: "function",
+    name: "fee",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint24" }]
+  },
+  // (Token-0 / token-1 cumulative fee growth per unit of liquidity, in
+  // Q128.128.) Used with `ticks(...)` to derive the pending-fee estimate
+  // for collectFeesDirect.
+  {
+    type: "function",
+    name: "feeGrowthGlobal0X128",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "feeGrowthGlobal1X128",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Per-tick state. The SDK reads `ticks(tickLower)` + `ticks(tickUpper)`
+  // for a position to compute its `feeGrowthInside0/1` in the canonical
+  // V3 formula (current global - outside lower - outside upper, branched
+  // on whether `slot0.tick` is below / inside / above the range).
+  {
+    type: "function",
+    name: "ticks",
+    stateMutability: "view",
+    inputs: [{ name: "tick", type: "int24" }],
+    outputs: [
+      { name: "liquidityGross", type: "uint128" },
+      { name: "liquidityNet", type: "int128" },
+      { name: "feeGrowthOutside0X128", type: "uint256" },
+      { name: "feeGrowthOutside1X128", type: "uint256" },
+      { name: "tickCumulativeOutside", type: "int56" },
+      { name: "secondsPerLiquidityOutsideX128", type: "uint160" },
+      { name: "secondsOutside", type: "uint56" },
+      { name: "initialized", type: "bool" }
+    ]
+  },
+  // Per-word initialized-tick bitset. Each uint256 word covers 256
+  // compressed tick positions (compressed = tick / tickSpacing). The
+  // off-chain liquidity-curve scanner reads every word in
+  // `[wordOf(minUsableTick), wordOf(maxUsableTick)]` then decodes set
+  // bits into absolute tick indices via `(wordPos * 256 + bit) * spacing`.
+  // See `fetchAllInitializedTicks.ts`.
+  {
+    type: "function",
+    name: "tickBitmap",
+    stateMutability: "view",
+    inputs: [{ name: "wordPosition", type: "int16" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+
+// src/liquidity/constants.ts
+var V3_NPM_ADDRESSES = {
+  // Base mainnet — PAFI's V3 NPM deployment.
+  8453: "0xD7db6931B5EbeaE033605db0781DE6C91F05CCdf"
+};
+var UINT128_MAX2 = (1n << 128n) - 1n;
+
+// src/liquidity/math.ts
+var MIN_TICK = -887272;
+var MAX_TICK = 887272;
+var MIN_SQRT_RATIO = 4295128739n;
+var MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
+var Q96 = 1n << 96n;
+var Q192 = 1n << 192n;
+function mulShift(val, mulBy) {
+  return val * mulBy >> 128n;
+}
+function mulDivFloor(a, b, denominator) {
+  return a * b / denominator;
+}
+function mulDivCeil(a, b, denominator) {
+  const product = a * b;
+  return product % denominator === 0n ? product / denominator : product / denominator + 1n;
+}
+function tickToSqrtPriceX96(tick) {
+  if (!Number.isInteger(tick)) {
+    throw new Error(`tickToSqrtPriceX96: tick must be an integer, got ${tick}`);
+  }
+  if (tick < MIN_TICK || tick > MAX_TICK) {
+    throw new Error(
+      `tickToSqrtPriceX96: tick ${tick} out of range [${MIN_TICK}, ${MAX_TICK}]`
+    );
+  }
+  const absTick = BigInt(tick < 0 ? -tick : tick);
+  let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+  if ((absTick & 0x2n) !== 0n)
+    ratio = mulShift(ratio, 0xfff97272373d413259a46990580e213an);
+  if ((absTick & 0x4n) !== 0n)
+    ratio = mulShift(ratio, 0xfff2e50f5f656932ef12357cf3c7fdccn);
+  if ((absTick & 0x8n) !== 0n)
+    ratio = mulShift(ratio, 0xffe5caca7e10e4e61c3624eaa0941cd0n);
+  if ((absTick & 0x10n) !== 0n)
+    ratio = mulShift(ratio, 0xffcb9843d60f6159c9db58835c926644n);
+  if ((absTick & 0x20n) !== 0n)
+    ratio = mulShift(ratio, 0xff973b41fa98c081472e6896dfb254c0n);
+  if ((absTick & 0x40n) !== 0n)
+    ratio = mulShift(ratio, 0xff2ea16466c96a3843ec78b326b52861n);
+  if ((absTick & 0x80n) !== 0n)
+    ratio = mulShift(ratio, 0xfe5dee046a99a2a811c461f1969c3053n);
+  if ((absTick & 0x100n) !== 0n)
+    ratio = mulShift(ratio, 0xfcbe86c7900a88aedcffc83b479aa3a4n);
+  if ((absTick & 0x200n) !== 0n)
+    ratio = mulShift(ratio, 0xf987a7253ac413176f2b074cf7815e54n);
+  if ((absTick & 0x400n) !== 0n)
+    ratio = mulShift(ratio, 0xf3392b0822b70005940c7a398e4b70f3n);
+  if ((absTick & 0x800n) !== 0n)
+    ratio = mulShift(ratio, 0xe7159475a2c29b7443b29c7fa6e889d9n);
+  if ((absTick & 0x1000n) !== 0n)
+    ratio = mulShift(ratio, 0xd097f3bdfd2022b8845ad8f792aa5825n);
+  if ((absTick & 0x2000n) !== 0n)
+    ratio = mulShift(ratio, 0xa9f746462d870fdf8a65dc1f90e061e5n);
+  if ((absTick & 0x4000n) !== 0n)
+    ratio = mulShift(ratio, 0x70d869a156d2a1b890bb3df62baf32f7n);
+  if ((absTick & 0x8000n) !== 0n)
+    ratio = mulShift(ratio, 0x31be135f97d08fd981231505542fcfa6n);
+  if ((absTick & 0x10000n) !== 0n)
+    ratio = mulShift(ratio, 0x9aa508b5b7a84e1c677de54f3e99bc9n);
+  if ((absTick & 0x20000n) !== 0n)
+    ratio = mulShift(ratio, 0x5d6af8dedb81196699c329225ee604n);
+  if ((absTick & 0x40000n) !== 0n)
+    ratio = mulShift(ratio, 0x2216e584f5fa1ea926041bedfe98n);
+  if ((absTick & 0x80000n) !== 0n)
+    ratio = mulShift(ratio, 0x48a170391f7dc42444e8fa2n);
+  if (tick > 0) {
+    const max256 = (1n << 256n) - 1n;
+    ratio = max256 / ratio;
+  }
+  return (ratio >> 32n) + (ratio % (1n << 32n) === 0n ? 0n : 1n);
+}
+function sqrtPriceX96ToTick(sqrtPriceX96) {
+  if (sqrtPriceX96 < MIN_SQRT_RATIO || sqrtPriceX96 >= MAX_SQRT_RATIO) {
+    throw new Error(
+      `sqrtPriceX96ToTick: sqrtPriceX96 ${sqrtPriceX96} out of range [${MIN_SQRT_RATIO}, ${MAX_SQRT_RATIO})`
+    );
+  }
+  const ratio = sqrtPriceX96 << 32n;
+  let r = ratio;
+  let msb = 0n;
+  for (const [shift, value] of [
+    [128n, 0xffffffffffffffffffffffffffffffffn],
+    [64n, 0xffffffffffffffffn],
+    [32n, 0xffffffffn],
+    [16n, 0xffffn],
+    [8n, 0xffn],
+    [4n, 0xfn],
+    [2n, 0x3n],
+    [1n, 0x1n]
+  ]) {
+    const f = r > value ? shift : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  r = msb >= 128n ? ratio >> msb - 127n : ratio << 127n - msb;
+  let log2 = msb - 128n << 64n;
+  for (let i = 0; i < 14; i++) {
+    r = r * r >> 127n;
+    const f = r >> 128n;
+    log2 |= f << BigInt(63 - i);
+    r >>= f;
+  }
+  const logSqrt10001 = log2 * 255738958999603826347141n;
+  const tickLow = Number(
+    logSqrt10001 - 3402992956809132418596140100660247210n >> 128n
+  );
+  const tickHigh = Number(
+    logSqrt10001 + 291339464771989622907027621153398088495n >> 128n
+  );
+  if (tickLow === tickHigh) return tickLow;
+  return tickToSqrtPriceX96(tickHigh) <= sqrtPriceX96 ? tickHigh : tickLow;
+}
+function nearestUsableTick(tick, tickSpacing) {
+  if (!Number.isInteger(tick) || !Number.isInteger(tickSpacing)) {
+    throw new Error("nearestUsableTick: both arguments must be integers");
+  }
+  if (tickSpacing <= 0) {
+    throw new Error(
+      `nearestUsableTick: tickSpacing must be positive, got ${tickSpacing}`
+    );
+  }
+  const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+  if (rounded < MIN_TICK) return rounded + tickSpacing;
+  if (rounded > MAX_TICK) return rounded - tickSpacing;
+  return rounded;
+}
+function minUsableTick(tickSpacing) {
+  return Math.ceil(MIN_TICK / tickSpacing) * tickSpacing;
+}
+function maxUsableTick(tickSpacing) {
+  return Math.floor(MAX_TICK / tickSpacing) * tickSpacing;
+}
+function tickSpacingForFee(fee) {
+  switch (fee) {
+    case 100:
+      return 1;
+    case 500:
+      return 10;
+    case 3e3:
+      return 60;
+    case 1e4:
+      return 200;
+    default:
+      return void 0;
+  }
+}
+function priceToTick(params) {
+  const { price, token0Decimals, token1Decimals } = params;
+  if (price <= 0 || !Number.isFinite(price)) {
+    throw new Error(`priceToTick: price must be a positive finite number, got ${price}`);
+  }
+  const rawPrice = price * 10 ** (token1Decimals - token0Decimals);
+  return Math.floor(Math.log(rawPrice) / Math.log(1.0001));
+}
+function tickToPrice(params) {
+  const { tick, token0Decimals, token1Decimals } = params;
+  if (!Number.isInteger(tick)) {
+    throw new Error(`tickToPrice: tick must be an integer, got ${tick}`);
+  }
+  const rawPrice = Math.pow(1.0001, tick);
+  return rawPrice / 10 ** (token1Decimals - token0Decimals);
+}
+function getAmount0ForLiquidity(sqrtPriceX96Lower, sqrtPriceX96Upper, liquidity) {
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  if (liquidity <= 0n) return 0n;
+  const numerator = liquidity << 96n;
+  const diff = sqrtPriceX96Upper - sqrtPriceX96Lower;
+  return mulDivCeil(numerator * diff, 1n, sqrtPriceX96Upper * sqrtPriceX96Lower);
+}
+function getAmount1ForLiquidity(sqrtPriceX96Lower, sqrtPriceX96Upper, liquidity) {
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  if (liquidity <= 0n) return 0n;
+  return mulDivCeil(liquidity, sqrtPriceX96Upper - sqrtPriceX96Lower, Q96);
+}
+function getAmountsForLiquidity(params) {
+  let { sqrtPriceX96Lower, sqrtPriceX96Upper } = params;
+  const { sqrtPriceX96Current, liquidity } = params;
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  if (sqrtPriceX96Current <= sqrtPriceX96Lower) {
+    return {
+      amount0: getAmount0ForLiquidity(
+        sqrtPriceX96Lower,
+        sqrtPriceX96Upper,
+        liquidity
+      ),
+      amount1: 0n
+    };
+  } else if (sqrtPriceX96Current < sqrtPriceX96Upper) {
+    return {
+      amount0: getAmount0ForLiquidity(
+        sqrtPriceX96Current,
+        sqrtPriceX96Upper,
+        liquidity
+      ),
+      amount1: getAmount1ForLiquidity(
+        sqrtPriceX96Lower,
+        sqrtPriceX96Current,
+        liquidity
+      )
+    };
+  } else {
+    return {
+      amount0: 0n,
+      amount1: getAmount1ForLiquidity(
+        sqrtPriceX96Lower,
+        sqrtPriceX96Upper,
+        liquidity
+      )
+    };
+  }
+}
+function getLiquidityForAmount0(sqrtPriceX96Lower, sqrtPriceX96Upper, amount0) {
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  if (amount0 <= 0n) return 0n;
+  const intermediate = mulDivFloor(sqrtPriceX96Lower, sqrtPriceX96Upper, Q96);
+  return mulDivFloor(amount0, intermediate, sqrtPriceX96Upper - sqrtPriceX96Lower);
+}
+function getLiquidityForAmount1(sqrtPriceX96Lower, sqrtPriceX96Upper, amount1) {
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  if (amount1 <= 0n) return 0n;
+  return mulDivFloor(amount1, Q96, sqrtPriceX96Upper - sqrtPriceX96Lower);
+}
+function estimateLiquidityFromOneSide(params) {
+  let { sqrtPriceX96Lower, sqrtPriceX96Upper } = params;
+  const {
+    sqrtPriceX96Current,
+    amount0Desired,
+    amount1Desired
+  } = params;
+  if (sqrtPriceX96Lower > sqrtPriceX96Upper) {
+    [sqrtPriceX96Lower, sqrtPriceX96Upper] = [
+      sqrtPriceX96Upper,
+      sqrtPriceX96Lower
+    ];
+  }
+  const has0 = amount0Desired !== void 0 && amount0Desired > 0n;
+  const has1 = amount1Desired !== void 0 && amount1Desired > 0n;
+  if (has0 === has1) {
+    throw new Error(
+      "estimateLiquidityFromOneSide: exactly one of amount0Desired / amount1Desired must be a positive bigint"
+    );
+  }
+  if (sqrtPriceX96Current <= sqrtPriceX96Lower) {
+    if (!has0) {
+      throw new Error(
+        "estimateLiquidityFromOneSide: spot is below range; pin amount0Desired (token1 isn't required)"
+      );
+    }
+    const liquidity2 = getLiquidityForAmount0(
+      sqrtPriceX96Lower,
+      sqrtPriceX96Upper,
+      amount0Desired
+    );
+    return { liquidity: liquidity2, amount0: amount0Desired, amount1: 0n };
+  }
+  if (sqrtPriceX96Current >= sqrtPriceX96Upper) {
+    if (!has1) {
+      throw new Error(
+        "estimateLiquidityFromOneSide: spot is above range; pin amount1Desired (token0 isn't required)"
+      );
+    }
+    const liquidity2 = getLiquidityForAmount1(
+      sqrtPriceX96Lower,
+      sqrtPriceX96Upper,
+      amount1Desired
+    );
+    return { liquidity: liquidity2, amount0: 0n, amount1: amount1Desired };
+  }
+  let liquidity;
+  if (has0) {
+    liquidity = getLiquidityForAmount0(
+      sqrtPriceX96Current,
+      sqrtPriceX96Upper,
+      amount0Desired
+    );
+  } else {
+    liquidity = getLiquidityForAmount1(
+      sqrtPriceX96Lower,
+      sqrtPriceX96Current,
+      amount1Desired
+    );
+  }
+  const amounts = getAmountsForLiquidity({
+    sqrtPriceX96Current,
+    sqrtPriceX96Lower,
+    sqrtPriceX96Upper,
+    liquidity
+  });
+  return {
+    liquidity,
+    amount0: has0 ? amount0Desired : amounts.amount0,
+    amount1: has1 ? amount1Desired : amounts.amount1
+  };
+}
+function applyMintSlippage(params) {
+  const { amount0Desired, amount1Desired, slippageBps } = params;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `applyMintSlippage: slippageBps must be integer in [0, 10000], got ${slippageBps}`
+    );
+  }
+  const num = BigInt(1e4 - slippageBps);
+  return {
+    amount0Min: amount0Desired * num / 10000n,
+    amount1Min: amount1Desired * num / 10000n
+  };
+}
+function applyRemoveSlippage(params) {
+  const { amount0Expected, amount1Expected, slippageBps } = params;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `applyRemoveSlippage: slippageBps must be integer in [0, 10000], got ${slippageBps}`
+    );
+  }
+  const num = BigInt(1e4 - slippageBps);
+  return {
+    amount0Min: amount0Expected * num / 10000n,
+    amount1Min: amount1Expected * num / 10000n
+  };
+}
+
+// src/liquidity/readPosition.ts
+async function readPosition(client, npm, tokenId) {
+  const result = await client.readContract({
+    address: npm,
+    abi: nonfungiblePositionManagerAbi,
+    functionName: "positions",
+    args: [tokenId]
+  });
+  return {
+    nonce: result[0],
+    operator: result[1],
+    token0: result[2],
+    token1: result[3],
+    fee: result[4],
+    tickLower: result[5],
+    tickUpper: result[6],
+    liquidity: result[7],
+    feeGrowthInside0LastX128: result[8],
+    feeGrowthInside1LastX128: result[9],
+    tokensOwed0: result[10],
+    tokensOwed1: result[11]
+  };
+}
+
+// src/liquidity/readPoolState.ts
+async function readPoolState(client, pool, blockNumber) {
+  const results = await client.multicall({
+    contracts: [
+      { address: pool, abi: v3PoolAbi, functionName: "slot0" },
+      { address: pool, abi: v3PoolAbi, functionName: "liquidity" },
+      { address: pool, abi: v3PoolAbi, functionName: "tickSpacing" },
+      { address: pool, abi: v3PoolAbi, functionName: "fee" }
+    ],
+    allowFailure: false,
+    blockNumber
+  });
+  const slot0 = results[0];
+  return {
+    sqrtPriceX96: slot0[0],
+    tick: slot0[1],
+    liquidity: results[1],
+    tickSpacing: results[2],
+    fee: results[3]
+  };
+}
+async function readTicksAt(client, pool, tickLower, tickUpper) {
+  const results = await client.multicall({
+    contracts: [
+      { address: pool, abi: v3PoolAbi, functionName: "ticks", args: [tickLower] },
+      { address: pool, abi: v3PoolAbi, functionName: "ticks", args: [tickUpper] }
+    ],
+    allowFailure: false
+  });
+  const toTickInfo = (r) => {
+    const tuple = r;
+    return {
+      liquidityGross: tuple[0],
+      liquidityNet: tuple[1],
+      feeGrowthOutside0X128: tuple[2],
+      feeGrowthOutside1X128: tuple[3],
+      initialized: tuple[7]
+    };
+  };
+  return {
+    lower: toTickInfo(results[0]),
+    upper: toTickInfo(results[1])
+  };
+}
+async function readFeeGrowthGlobals(client, pool) {
+  const results = await client.multicall({
+    contracts: [
+      { address: pool, abi: v3PoolAbi, functionName: "feeGrowthGlobal0X128" },
+      { address: pool, abi: v3PoolAbi, functionName: "feeGrowthGlobal1X128" }
+    ],
+    allowFailure: false
+  });
+  return {
+    feeGrowthGlobal0X128: results[0],
+    feeGrowthGlobal1X128: results[1]
+  };
+}
+
+// src/liquidity/buildMint.ts
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+import { erc20ApproveOp as erc20ApproveOp2 } from "@pafi-dev/core";
+function buildMint(params) {
+  return [
+    erc20ApproveOp2(params.token0, params.npm, params.amount0Desired),
+    erc20ApproveOp2(params.token1, params.npm, params.amount1Desired),
+    {
+      target: params.npm,
+      value: 0n,
+      data: encodeFunctionData3({
+        abi: nonfungiblePositionManagerAbi,
+        functionName: "mint",
+        args: [
+          {
+            token0: params.token0,
+            token1: params.token1,
+            fee: params.fee,
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            amount0Desired: params.amount0Desired,
+            amount1Desired: params.amount1Desired,
+            amount0Min: params.amount0Min,
+            amount1Min: params.amount1Min,
+            recipient: params.recipient,
+            deadline: params.deadline
+          }
+        ]
+      })
+    }
+  ];
+}
+
+// src/liquidity/buildIncreaseLiquidity.ts
+import { encodeFunctionData as encodeFunctionData4 } from "viem";
+import { erc20ApproveOp as erc20ApproveOp3 } from "@pafi-dev/core";
+function buildIncreaseLiquidity(params) {
+  return [
+    erc20ApproveOp3(params.token0, params.npm, params.amount0Desired),
+    erc20ApproveOp3(params.token1, params.npm, params.amount1Desired),
+    {
+      target: params.npm,
+      value: 0n,
+      data: encodeFunctionData4({
+        abi: nonfungiblePositionManagerAbi,
+        functionName: "increaseLiquidity",
+        args: [
+          {
+            tokenId: params.tokenId,
+            amount0Desired: params.amount0Desired,
+            amount1Desired: params.amount1Desired,
+            amount0Min: params.amount0Min,
+            amount1Min: params.amount1Min,
+            deadline: params.deadline
+          }
+        ]
+      })
+    }
+  ];
+}
+
+// src/liquidity/buildDecreaseLiquidity.ts
+import { encodeFunctionData as encodeFunctionData5 } from "viem";
+function buildDecreaseLiquidity(params) {
+  return {
+    target: params.npm,
+    value: 0n,
+    data: encodeFunctionData5({
+      abi: nonfungiblePositionManagerAbi,
+      functionName: "decreaseLiquidity",
+      args: [
+        {
+          tokenId: params.tokenId,
+          liquidity: params.liquidity,
+          amount0Min: params.amount0Min,
+          amount1Min: params.amount1Min,
+          deadline: params.deadline
+        }
+      ]
+    })
+  };
+}
+
+// src/liquidity/buildCollect.ts
+import { encodeFunctionData as encodeFunctionData6 } from "viem";
+function buildCollect(params) {
+  return {
+    target: params.npm,
+    value: 0n,
+    data: encodeFunctionData6({
+      abi: nonfungiblePositionManagerAbi,
+      functionName: "collect",
+      args: [
+        {
+          tokenId: params.tokenId,
+          recipient: params.recipient,
+          amount0Max: params.amount0Max ?? UINT128_MAX2,
+          amount1Max: params.amount1Max ?? UINT128_MAX2
+        }
+      ]
+    })
+  };
+}
+
+// src/liquidity/buildBurn.ts
+import { encodeFunctionData as encodeFunctionData7 } from "viem";
+function buildBurn(params) {
+  return {
+    target: params.npm,
+    value: 0n,
+    data: encodeFunctionData7({
+      abi: nonfungiblePositionManagerAbi,
+      functionName: "burn",
+      args: [params.tokenId]
+    })
+  };
+}
+
+// src/liquidity/buildClosePosition.ts
+function buildClosePosition(params) {
+  const ops = [];
+  if (params.liquidity > 0n) {
+    ops.push(
+      buildDecreaseLiquidity({
+        npm: params.npm,
+        tokenId: params.tokenId,
+        liquidity: params.liquidity,
+        amount0Min: params.amount0Min,
+        amount1Min: params.amount1Min,
+        deadline: params.deadline
+      })
+    );
+  }
+  if (params.liquidity > 0n || params.hasOutstandingFees) {
+    ops.push(
+      buildCollect({
+        npm: params.npm,
+        tokenId: params.tokenId,
+        recipient: params.recipient
+      })
+    );
+  }
+  ops.push(buildBurn({ npm: params.npm, tokenId: params.tokenId }));
+  return ops;
+}
+
+// src/liquidity/readTickBitmap.ts
+function tickToBitmapPosition(tick, tickSpacing) {
+  if (!Number.isInteger(tick)) {
+    throw new Error(`tickToBitmapPosition: tick (${tick}) must be an integer`);
+  }
+  if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) {
+    throw new Error(
+      `tickToBitmapPosition: tickSpacing (${tickSpacing}) must be a positive integer`
+    );
+  }
+  if (tick % tickSpacing !== 0) {
+    throw new Error(
+      `tickToBitmapPosition: tick (${tick}) must be a multiple of tickSpacing ${tickSpacing}`
+    );
+  }
+  const compressed = Math.floor(tick / tickSpacing);
+  const word = compressed >> 8;
+  const bit = (compressed % 256 + 256) % 256;
+  return { word, bit };
+}
+function decodeBitmapWord(bitmap, wordPos, tickSpacing) {
+  if (bitmap === 0n) return [];
+  const out = [];
+  for (let bit = 0; bit < 256; bit++) {
+    if ((bitmap & 1n << BigInt(bit)) !== 0n) {
+      out.push((wordPos * 256 + bit) * tickSpacing);
+    }
+  }
+  return out;
+}
+function bitmapWordRange(tickSpacing) {
+  const lo = minUsableTick(tickSpacing);
+  const hi = maxUsableTick(tickSpacing);
+  return {
+    min: Math.floor(lo / tickSpacing) >> 8,
+    max: Math.floor(hi / tickSpacing) >> 8
+  };
+}
+
+// src/liquidity/buildLiquidityCurve.ts
+var LiquidityCurveErrorCode = /* @__PURE__ */ ((LiquidityCurveErrorCode2) => {
+  LiquidityCurveErrorCode2["TOO_MANY_TICKS"] = "TOO_MANY_TICKS";
+  LiquidityCurveErrorCode2["ATOMICITY_VIOLATION"] = "ATOMICITY_VIOLATION";
+  LiquidityCurveErrorCode2["CURVE_SUM_NONZERO"] = "CURVE_SUM_NONZERO";
+  LiquidityCurveErrorCode2["CURVE_NEGATIVE_L"] = "CURVE_NEGATIVE_L";
+  LiquidityCurveErrorCode2["CURVE_EDGE_NONZERO"] = "CURVE_EDGE_NONZERO";
+  return LiquidityCurveErrorCode2;
+})(LiquidityCurveErrorCode || {});
+var LiquidityCurveError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "LiquidityCurveError";
+    this.code = code;
+  }
+};
+function buildLiquidityCurve(params) {
+  const { ticks, currentTick, currentLiquidity, tickSpacing } = params;
+  const TICK_LO = minUsableTick(tickSpacing);
+  const TICK_HI = maxUsableTick(tickSpacing);
+  const N = ticks.length;
+  const sumNet = ticks.reduce((acc, t) => acc + t.liquidityNet, 0n);
+  if (sumNet !== 0n) {
+    throw new LiquidityCurveError(
+      "CURVE_SUM_NONZERO" /* CURVE_SUM_NONZERO */,
+      `buildLiquidityCurve: sum(liquidityNet) = ${sumNet}, expected 0. Tick set is incomplete or fetched at a different block.`
+    );
+  }
+  if (N === 0) {
+    return [
+      {
+        tickLower: TICK_LO,
+        tickUpper: TICK_HI,
+        sqrtPriceLowerX96: tickToSqrtPriceX96(TICK_LO),
+        sqrtPriceUpperX96: tickToSqrtPriceX96(TICK_HI),
+        liquidityActive: currentLiquidity
+      }
+    ];
+  }
+  let lo = 0;
+  let hi = N;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (ticks[mid].tick > currentTick) hi = mid;
+    else lo = mid + 1;
+  }
+  const i_above = lo;
+  const i_below = i_above - 1;
+  const segments = new Array(N + 1);
+  const anchorLower = i_below >= 0 ? ticks[i_below].tick : TICK_LO;
+  const anchorUpper = i_above < N ? ticks[i_above].tick : TICK_HI;
+  segments[i_above] = {
+    tickLower: anchorLower,
+    tickUpper: anchorUpper,
+    sqrtPriceLowerX96: 0n,
+    // filled below
+    sqrtPriceUpperX96: 0n,
+    liquidityActive: currentLiquidity
+  };
+  let L = currentLiquidity;
+  for (let k = i_below; k >= 0; k--) {
+    L = L - ticks[k].liquidityNet;
+    if (L < 0n) {
+      throw new LiquidityCurveError(
+        "CURVE_NEGATIVE_L" /* CURVE_NEGATIVE_L */,
+        `buildLiquidityCurve: active liquidity went negative at tick ${ticks[k].tick} during left walk. Indicates inconsistent input.`
+      );
+    }
+    const lower = k - 1 >= 0 ? ticks[k - 1].tick : TICK_LO;
+    segments[k] = {
+      tickLower: lower,
+      tickUpper: ticks[k].tick,
+      sqrtPriceLowerX96: 0n,
+      sqrtPriceUpperX96: 0n,
+      liquidityActive: L
+    };
+  }
+  L = currentLiquidity;
+  for (let j = i_above; j < N; j++) {
+    L = L + ticks[j].liquidityNet;
+    if (L < 0n) {
+      throw new LiquidityCurveError(
+        "CURVE_NEGATIVE_L" /* CURVE_NEGATIVE_L */,
+        `buildLiquidityCurve: active liquidity went negative at tick ${ticks[j].tick} during right walk.`
+      );
+    }
+    const upper = j + 1 < N ? ticks[j + 1].tick : TICK_HI;
+    segments[j + 1] = {
+      tickLower: ticks[j].tick,
+      tickUpper: upper,
+      sqrtPriceLowerX96: 0n,
+      sqrtPriceUpperX96: 0n,
+      liquidityActive: L
+    };
+  }
+  if (segments[0].liquidityActive !== 0n) {
+    throw new LiquidityCurveError(
+      "CURVE_EDGE_NONZERO" /* CURVE_EDGE_NONZERO */,
+      `buildLiquidityCurve: leftmost L = ${segments[0].liquidityActive}, expected 0. currentLiquidity inconsistent with tick set.`
+    );
+  }
+  if (segments[N].liquidityActive !== 0n) {
+    throw new LiquidityCurveError(
+      "CURVE_EDGE_NONZERO" /* CURVE_EDGE_NONZERO */,
+      `buildLiquidityCurve: rightmost L = ${segments[N].liquidityActive}, expected 0.`
+    );
+  }
+  for (const seg of segments) {
+    seg.sqrtPriceLowerX96 = tickToSqrtPriceX96(seg.tickLower);
+    seg.sqrtPriceUpperX96 = tickToSqrtPriceX96(seg.tickUpper);
+  }
+  return segments;
+}
+function clipCurveToTickRange(curve, tickLo, tickHi) {
+  if (curve.length === 0 || tickHi <= tickLo) return [];
+  let lo = 0;
+  let hi = curve.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (curve[mid].tickUpper > tickLo) hi = mid;
+    else lo = mid + 1;
+  }
+  const startIdx = lo;
+  lo = 0;
+  hi = curve.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (curve[mid].tickLower >= tickHi) hi = mid;
+    else lo = mid + 1;
+  }
+  const endIdx = lo;
+  if (startIdx >= endIdx) return [];
+  const out = [];
+  for (let i = startIdx; i < endIdx; i++) {
+    const seg = curve[i];
+    const newLower = Math.max(seg.tickLower, tickLo);
+    const newUpper = Math.min(seg.tickUpper, tickHi);
+    if (newLower === seg.tickLower && newUpper === seg.tickUpper) {
+      out.push(seg);
+    } else {
+      out.push({
+        tickLower: newLower,
+        tickUpper: newUpper,
+        sqrtPriceLowerX96: tickToSqrtPriceX96(newLower),
+        sqrtPriceUpperX96: tickToSqrtPriceX96(newUpper),
+        liquidityActive: seg.liquidityActive
+      });
+    }
+  }
+  return out;
+}
+
+// src/liquidity/fetchAllInitializedTicks.ts
+var CALLDATA_BYTES_PER_CALL = 36;
+var DEFAULT_CALLS_PER_BATCH = 250;
+var DEFAULT_MAX_TICKS = 5e4;
+async function fetchAllInitializedTicks(params) {
+  const callsPerBatch = params.callsPerBatch ?? DEFAULT_CALLS_PER_BATCH;
+  const maxTicks = params.maxTicks ?? DEFAULT_MAX_TICKS;
+  const batchSizeBytes = callsPerBatch * CALLDATA_BYTES_PER_CALL;
+  const blockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+  let tickSpacing = params.tickSpacing;
+  if (tickSpacing === void 0) {
+    const [resolved] = await params.client.multicall({
+      contracts: [
+        {
+          address: params.pool,
+          abi: v3PoolAbi,
+          functionName: "tickSpacing"
+        }
+      ],
+      allowFailure: false,
+      blockNumber,
+      batchSize: batchSizeBytes
+    });
+    tickSpacing = Number(resolved);
+  }
+  const { min: wordLo, max: wordHi } = bitmapWordRange(tickSpacing);
+  const bitmapContracts = [];
+  for (let w = wordLo; w <= wordHi; w++) {
+    bitmapContracts.push({
+      address: params.pool,
+      abi: v3PoolAbi,
+      functionName: "tickBitmap",
+      args: [w]
+    });
+  }
+  const bitmaps = await params.client.multicall({
+    contracts: bitmapContracts,
+    allowFailure: false,
+    blockNumber,
+    batchSize: batchSizeBytes
+  });
+  const initTicks = [];
+  for (let i = 0; i < bitmaps.length; i++) {
+    const word = bitmaps[i];
+    if (word === 0n) continue;
+    const wordPos = wordLo + i;
+    const decoded = decodeBitmapWord(word, wordPos, tickSpacing);
+    for (const t of decoded) initTicks.push(t);
+  }
+  if (initTicks.length > maxTicks) {
+    throw new LiquidityCurveError(
+      "TOO_MANY_TICKS" /* TOO_MANY_TICKS */,
+      `fetchAllInitializedTicks: pool ${params.pool} has ${initTicks.length} initialized ticks, exceeds maxTicks=${maxTicks}. Pass maxTicks explicitly if you want the full set.`
+    );
+  }
+  if (initTicks.length === 0) {
+    return { blockNumber, tickSpacing, ticks: [] };
+  }
+  const ticksContracts = initTicks.map(
+    (tick) => ({
+      address: params.pool,
+      abi: v3PoolAbi,
+      functionName: "ticks",
+      args: [tick]
+    })
+  );
+  const ticksTuples = await params.client.multicall({
+    contracts: ticksContracts,
+    allowFailure: false,
+    blockNumber,
+    batchSize: batchSizeBytes
+  });
+  const ticks = ticksTuples.map((tuple, i) => ({
+    tick: initTicks[i],
+    liquidityGross: tuple[0],
+    liquidityNet: tuple[1],
+    feeGrowthOutside0X128: tuple[2],
+    feeGrowthOutside1X128: tuple[3],
+    initialized: tuple[7]
+  }));
+  for (const t of ticks) {
+    if (!t.initialized) {
+      throw new LiquidityCurveError(
+        "ATOMICITY_VIOLATION" /* ATOMICITY_VIOLATION */,
+        `fetchAllInitializedTicks: tick ${t.tick} bitmap-set but ticks().initialized=false at block ${blockNumber}. Snapshot is torn \u2014 RPC node likely served different blocks across batches.`
+      );
+    }
+  }
+  return { blockNumber, tickSpacing, ticks };
+}
+
+// src/liquidity/fetchLiquidityCurve.ts
+async function fetchLiquidityCurve(params) {
+  const blockNumber = params.blockNumber ?? await params.client.getBlockNumber();
+  const poolState = params.poolState ?? await readPoolState(params.client, params.pool, blockNumber);
+  const ticksResult = await fetchAllInitializedTicks({
+    client: params.client,
+    pool: params.pool,
+    blockNumber,
+    tickSpacing: poolState.tickSpacing,
+    callsPerBatch: params.callsPerBatch,
+    maxTicks: params.maxTicks
+  });
+  const curve = buildLiquidityCurve({
+    ticks: ticksResult.ticks,
+    currentTick: poolState.tick,
+    currentLiquidity: poolState.liquidity,
+    tickSpacing: poolState.tickSpacing
+  });
+  let lo = 0;
+  let hi = curve.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (curve[mid].tickUpper > poolState.tick) hi = mid;
+    else lo = mid + 1;
+  }
+  const currentSegmentIndex = lo;
+  return {
+    blockNumber,
+    poolState,
+    ticks: ticksResult.ticks,
+    curve,
+    currentSegmentIndex
+  };
+}
+
+// src/direct/addLiquidityDirect.ts
+async function addLiquidityDirect(params) {
+  const npm = V3_NPM_ADDRESSES[params.chainId];
+  if (!npm) {
+    throw new Error(
+      `addLiquidityDirect: no NonfungiblePositionManager for chainId ${params.chainId}`
+    );
+  }
+  const factory = V3_FACTORY_ADDRESSES[params.chainId];
+  if (!factory) {
+    throw new Error(
+      `addLiquidityDirect: no V3 factory for chainId ${params.chainId}`
+    );
+  }
+  if (params.tickLower >= params.tickUpper) {
+    throw new Error(
+      `addLiquidityDirect: tickLower (${params.tickLower}) must be strictly less than tickUpper (${params.tickUpper})`
+    );
+  }
+  const ts = tickSpacingForFee(params.fee);
+  if (ts !== void 0) {
+    if (params.tickLower % ts !== 0 || params.tickUpper % ts !== 0) {
+      throw new Error(
+        `addLiquidityDirect: ticks must be multiples of tickSpacing ${ts} for fee ${params.fee}`
+      );
+    }
+  }
+  const has0 = params.amount0Desired !== void 0 && params.amount0Desired > 0n;
+  const has1 = params.amount1Desired !== void 0 && params.amount1Desired > 0n;
+  if (has0 === has1) {
+    throw new Error(
+      "addLiquidityDirect: exactly one of amount0Desired / amount1Desired must be a positive bigint"
+    );
+  }
+  const slippageBps = params.slippageBps ?? 50;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `addLiquidityDirect: slippageBps (${slippageBps}) must be an integer in [0, 10000]`
+    );
+  }
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error(
+      "addLiquidityDirect: walletClient has no account attached \u2014 cannot send tx"
+    );
+  }
+  if (account.address.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new Error(
+      `addLiquidityDirect: walletClient.account.address (${account.address}) must equal userAddress (${params.userAddress})`
+    );
+  }
+  const code = await params.publicClient.getCode({ address: params.userAddress });
+  const delegate = parseEip7702DelegatedAddress5(code);
+  if (!delegate) {
+    throw new Error(
+      `addLiquidityDirect: user ${params.userAddress} is not EIP-7702 delegated. Run \`delegateDirect()\` first or use the AA path.`
+    );
+  }
+  const pool = computeV3PoolAddress({
+    factory,
+    tokenA: params.token0,
+    tokenB: params.token1,
+    fee: params.fee,
+    initCodeHash: V3_POOL_INIT_CODE_HASH
+  });
+  const poolState = await readPoolState(params.publicClient, pool);
+  const sqrtL = tickToSqrtPriceX96(params.tickLower);
+  const sqrtU = tickToSqrtPriceX96(params.tickUpper);
+  const { liquidity, amount0, amount1 } = estimateLiquidityFromOneSide({
+    sqrtPriceX96Current: poolState.sqrtPriceX96,
+    sqrtPriceX96Lower: sqrtL,
+    sqrtPriceX96Upper: sqrtU,
+    amount0Desired: params.amount0Desired,
+    amount1Desired: params.amount1Desired
+  });
+  const { amount0Min, amount1Min } = applyMintSlippage({
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    slippageBps
+  });
+  const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+  const operations = buildMint({
+    npm,
+    token0: params.token0,
+    token1: params.token1,
+    fee: params.fee,
+    tickLower: params.tickLower,
+    tickUpper: params.tickUpper,
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    amount0Min,
+    amount1Min,
+    recipient: params.userAddress,
+    deadline
+  });
+  const partial = buildPartialUserOperation2({
+    sender: params.userAddress,
+    nonce: 0n,
+    operations
+  });
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: partial.callData
+  });
+  let receipt;
+  let tokenId;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
+      tokenId = parseMintedTokenId(receipt, npm, params.userAddress);
+    } catch (err) {
+      params.onWarning?.(
+        `addLiquidityDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    tokenId,
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    amount0Min,
+    amount1Min,
+    liquidity,
+    deadline
+  };
+}
+function parseMintedTokenId(receipt, npm, user) {
+  const userLower = user.toLowerCase();
+  const zero = "0x0000000000000000000000000000000000000000";
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() !== npm.toLowerCase()) continue;
+    try {
+      const decoded = decodeEventLog({
+        abi: nonfungiblePositionManagerAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName !== "Transfer") continue;
+      const args = decoded.args;
+      if (args.from.toLowerCase() === zero && args.to.toLowerCase() === userLower) {
+        return args.tokenId;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/direct/increaseLiquidityDirect.ts
+import {
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress6,
+  buildPartialUserOperation as buildPartialUserOperation3,
+  computeV3PoolAddress as computeV3PoolAddress2,
+  V3_FACTORY_ADDRESSES as V3_FACTORY_ADDRESSES2,
+  V3_POOL_INIT_CODE_HASH as V3_POOL_INIT_CODE_HASH2
+} from "@pafi-dev/core";
+async function increaseLiquidityDirect(params) {
+  const npm = V3_NPM_ADDRESSES[params.chainId];
+  if (!npm) {
+    throw new Error(
+      `increaseLiquidityDirect: no NonfungiblePositionManager for chainId ${params.chainId}`
+    );
+  }
+  const factory = V3_FACTORY_ADDRESSES2[params.chainId];
+  if (!factory) {
+    throw new Error(
+      `increaseLiquidityDirect: no V3 factory for chainId ${params.chainId}`
+    );
+  }
+  if (params.tokenId <= 0n) {
+    throw new Error("increaseLiquidityDirect: tokenId must be positive");
+  }
+  const has0 = params.amount0Desired !== void 0 && params.amount0Desired > 0n;
+  const has1 = params.amount1Desired !== void 0 && params.amount1Desired > 0n;
+  if (has0 === has1) {
+    throw new Error(
+      "increaseLiquidityDirect: exactly one of amount0Desired / amount1Desired must be a positive bigint"
+    );
+  }
+  const slippageBps = params.slippageBps ?? 50;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `increaseLiquidityDirect: slippageBps (${slippageBps}) must be an integer in [0, 10000]`
+    );
+  }
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error("increaseLiquidityDirect: walletClient has no account attached");
+  }
+  if (account.address.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new Error(
+      `increaseLiquidityDirect: walletClient.account.address (${account.address}) must equal userAddress (${params.userAddress})`
+    );
+  }
+  const code = await params.publicClient.getCode({ address: params.userAddress });
+  const delegate = parseEip7702DelegatedAddress6(code);
+  if (!delegate) {
+    throw new Error(
+      `increaseLiquidityDirect: user ${params.userAddress} is not EIP-7702 delegated.`
+    );
+  }
+  const position = await readPosition(params.publicClient, npm, params.tokenId);
+  const pool = computeV3PoolAddress2({
+    factory,
+    tokenA: position.token0,
+    tokenB: position.token1,
+    fee: position.fee,
+    initCodeHash: V3_POOL_INIT_CODE_HASH2
+  });
+  const poolState = await readPoolState(params.publicClient, pool);
+  const sqrtL = tickToSqrtPriceX96(position.tickLower);
+  const sqrtU = tickToSqrtPriceX96(position.tickUpper);
+  const { liquidity, amount0, amount1 } = estimateLiquidityFromOneSide({
+    sqrtPriceX96Current: poolState.sqrtPriceX96,
+    sqrtPriceX96Lower: sqrtL,
+    sqrtPriceX96Upper: sqrtU,
+    amount0Desired: params.amount0Desired,
+    amount1Desired: params.amount1Desired
+  });
+  const { amount0Min, amount1Min } = applyMintSlippage({
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    slippageBps
+  });
+  const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+  const operations = buildIncreaseLiquidity({
+    npm,
+    token0: position.token0,
+    token1: position.token1,
+    tokenId: params.tokenId,
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    amount0Min,
+    amount1Min,
+    deadline
+  });
+  const partial = buildPartialUserOperation3({
+    sender: params.userAddress,
+    nonce: 0n,
+    operations
+  });
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: partial.callData
+  });
+  let receipt;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      params.onWarning?.(
+        `increaseLiquidityDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    amount0Min,
+    amount1Min,
+    liquidityAdded: liquidity,
+    deadline
+  };
+}
+
+// src/direct/removeLiquidityDirect.ts
+import {
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress7,
+  buildPartialUserOperation as buildPartialUserOperation4,
+  computeV3PoolAddress as computeV3PoolAddress3,
+  V3_FACTORY_ADDRESSES as V3_FACTORY_ADDRESSES3,
+  V3_POOL_INIT_CODE_HASH as V3_POOL_INIT_CODE_HASH3
+} from "@pafi-dev/core";
+async function removeLiquidityDirect(params) {
+  const npm = V3_NPM_ADDRESSES[params.chainId];
+  if (!npm) {
+    throw new Error(
+      `removeLiquidityDirect: no NonfungiblePositionManager for chainId ${params.chainId}`
+    );
+  }
+  const factory = V3_FACTORY_ADDRESSES3[params.chainId];
+  if (!factory) {
+    throw new Error(`removeLiquidityDirect: no V3 factory for chainId ${params.chainId}`);
+  }
+  if (params.tokenId <= 0n) {
+    throw new Error("removeLiquidityDirect: tokenId must be positive");
+  }
+  const hasL = params.liquidity !== void 0 && params.liquidity > 0n;
+  const hasBps = params.liquidityBps !== void 0 && params.liquidityBps > 0 && params.liquidityBps <= 1e4;
+  if (hasL === hasBps) {
+    throw new Error(
+      "removeLiquidityDirect: exactly one of liquidity (>0) or liquidityBps (1..10000) must be set"
+    );
+  }
+  const slippageBps = params.slippageBps ?? 50;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `removeLiquidityDirect: slippageBps (${slippageBps}) must be an integer in [0, 10000]`
+    );
+  }
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error("removeLiquidityDirect: walletClient has no account attached");
+  }
+  if (account.address.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new Error(
+      `removeLiquidityDirect: walletClient.account.address (${account.address}) must equal userAddress (${params.userAddress})`
+    );
+  }
+  const code = await params.publicClient.getCode({ address: params.userAddress });
+  if (!parseEip7702DelegatedAddress7(code)) {
+    throw new Error(
+      `removeLiquidityDirect: user ${params.userAddress} is not EIP-7702 delegated.`
+    );
+  }
+  const position = await readPosition(params.publicClient, npm, params.tokenId);
+  if (position.liquidity === 0n) {
+    throw new Error(
+      `removeLiquidityDirect: position ${params.tokenId} has zero liquidity \u2014 nothing to remove`
+    );
+  }
+  const liquidityToRemove = hasL ? params.liquidity : position.liquidity * BigInt(params.liquidityBps) / 10000n;
+  if (liquidityToRemove === 0n) {
+    throw new Error(
+      "removeLiquidityDirect: computed liquidity to remove is zero (bps too small for position size)"
+    );
+  }
+  if (liquidityToRemove > position.liquidity) {
+    throw new Error(
+      `removeLiquidityDirect: liquidity to remove (${liquidityToRemove}) exceeds position liquidity (${position.liquidity})`
+    );
+  }
+  const pool = computeV3PoolAddress3({
+    factory,
+    tokenA: position.token0,
+    tokenB: position.token1,
+    fee: position.fee,
+    initCodeHash: V3_POOL_INIT_CODE_HASH3
+  });
+  const poolState = await readPoolState(params.publicClient, pool);
+  const { amount0: amount0Expected, amount1: amount1Expected } = getAmountsForLiquidity({
+    sqrtPriceX96Current: poolState.sqrtPriceX96,
+    sqrtPriceX96Lower: tickToSqrtPriceX96(position.tickLower),
+    sqrtPriceX96Upper: tickToSqrtPriceX96(position.tickUpper),
+    liquidity: liquidityToRemove
+  });
+  const { amount0Min, amount1Min } = applyRemoveSlippage({
+    amount0Expected,
+    amount1Expected,
+    slippageBps
+  });
+  const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+  const operations = [
+    buildDecreaseLiquidity({
+      npm,
+      tokenId: params.tokenId,
+      liquidity: liquidityToRemove,
+      amount0Min,
+      amount1Min,
+      deadline
+    }),
+    buildCollect({
+      npm,
+      tokenId: params.tokenId,
+      recipient: params.userAddress
+    })
+  ];
+  const partial = buildPartialUserOperation4({
+    sender: params.userAddress,
+    nonce: 0n,
+    operations
+  });
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: partial.callData
+  });
+  let receipt;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      params.onWarning?.(
+        `removeLiquidityDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    liquidityRemoved: liquidityToRemove,
+    amount0Expected,
+    amount1Expected,
+    amount0Min,
+    amount1Min,
+    deadline
+  };
+}
+
+// src/direct/closePositionDirect.ts
+import {
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress8,
+  buildPartialUserOperation as buildPartialUserOperation5,
+  computeV3PoolAddress as computeV3PoolAddress4,
+  V3_FACTORY_ADDRESSES as V3_FACTORY_ADDRESSES4,
+  V3_POOL_INIT_CODE_HASH as V3_POOL_INIT_CODE_HASH4
+} from "@pafi-dev/core";
+async function closePositionDirect(params) {
+  const npm = V3_NPM_ADDRESSES[params.chainId];
+  if (!npm) {
+    throw new Error(
+      `closePositionDirect: no NonfungiblePositionManager for chainId ${params.chainId}`
+    );
+  }
+  const factory = V3_FACTORY_ADDRESSES4[params.chainId];
+  if (!factory) {
+    throw new Error(`closePositionDirect: no V3 factory for chainId ${params.chainId}`);
+  }
+  if (params.tokenId <= 0n) {
+    throw new Error("closePositionDirect: tokenId must be positive");
+  }
+  const slippageBps = params.slippageBps ?? 50;
+  if (!Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 1e4) {
+    throw new Error(
+      `closePositionDirect: slippageBps (${slippageBps}) must be an integer in [0, 10000]`
+    );
+  }
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error("closePositionDirect: walletClient has no account attached");
+  }
+  if (account.address.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new Error(
+      `closePositionDirect: walletClient.account.address (${account.address}) must equal userAddress (${params.userAddress})`
+    );
+  }
+  const code = await params.publicClient.getCode({ address: params.userAddress });
+  if (!parseEip7702DelegatedAddress8(code)) {
+    throw new Error(
+      `closePositionDirect: user ${params.userAddress} is not EIP-7702 delegated.`
+    );
+  }
+  const position = await readPosition(params.publicClient, npm, params.tokenId);
+  let amount0Expected = 0n;
+  let amount1Expected = 0n;
+  let amount0Min = 0n;
+  let amount1Min = 0n;
+  if (position.liquidity > 0n) {
+    const pool = computeV3PoolAddress4({
+      factory,
+      tokenA: position.token0,
+      tokenB: position.token1,
+      fee: position.fee,
+      initCodeHash: V3_POOL_INIT_CODE_HASH4
+    });
+    const poolState = await readPoolState(params.publicClient, pool);
+    const amounts = getAmountsForLiquidity({
+      sqrtPriceX96Current: poolState.sqrtPriceX96,
+      sqrtPriceX96Lower: tickToSqrtPriceX96(position.tickLower),
+      sqrtPriceX96Upper: tickToSqrtPriceX96(position.tickUpper),
+      liquidity: position.liquidity
+    });
+    amount0Expected = amounts.amount0;
+    amount1Expected = amounts.amount1;
+    const min = applyRemoveSlippage({
+      amount0Expected,
+      amount1Expected,
+      slippageBps
+    });
+    amount0Min = min.amount0Min;
+    amount1Min = min.amount1Min;
+  }
+  const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+  const operations = buildClosePosition({
+    npm,
+    tokenId: params.tokenId,
+    liquidity: position.liquidity,
+    hasOutstandingFees: position.tokensOwed0 + position.tokensOwed1 > 0n,
+    recipient: params.userAddress,
+    amount0Min,
+    amount1Min,
+    deadline
+  });
+  const partial = buildPartialUserOperation5({
+    sender: params.userAddress,
+    nonce: 0n,
+    operations
+  });
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: partial.callData
+  });
+  let receipt;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      params.onWarning?.(
+        `closePositionDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    liquidityRemoved: position.liquidity,
+    amount0Expected,
+    amount1Expected,
+    amount0Min,
+    amount1Min,
+    deadline
+  };
+}
+
+// src/direct/collectFeesDirect.ts
+import {
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress9,
+  buildPartialUserOperation as buildPartialUserOperation6,
+  computeV3PoolAddress as computeV3PoolAddress5,
+  V3_FACTORY_ADDRESSES as V3_FACTORY_ADDRESSES5,
+  V3_POOL_INIT_CODE_HASH as V3_POOL_INIT_CODE_HASH5
+} from "@pafi-dev/core";
+async function collectFeesDirect(params) {
+  const npm = V3_NPM_ADDRESSES[params.chainId];
+  if (!npm) {
+    throw new Error(
+      `collectFeesDirect: no NonfungiblePositionManager for chainId ${params.chainId}`
+    );
+  }
+  const factory = V3_FACTORY_ADDRESSES5[params.chainId];
+  if (!factory) {
+    throw new Error(`collectFeesDirect: no V3 factory for chainId ${params.chainId}`);
+  }
+  if (params.tokenId <= 0n) {
+    throw new Error("collectFeesDirect: tokenId must be positive");
+  }
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error("collectFeesDirect: walletClient has no account attached");
+  }
+  if (account.address.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new Error(
+      `collectFeesDirect: walletClient.account.address (${account.address}) must equal userAddress (${params.userAddress})`
+    );
+  }
+  const code = await params.publicClient.getCode({ address: params.userAddress });
+  if (!parseEip7702DelegatedAddress9(code)) {
+    throw new Error(
+      `collectFeesDirect: user ${params.userAddress} is not EIP-7702 delegated.`
+    );
+  }
+  const position = await readPosition(params.publicClient, npm, params.tokenId);
+  let amount0Expected = position.tokensOwed0;
+  let amount1Expected = position.tokensOwed1;
+  if (position.liquidity > 0n) {
+    const pool = computeV3PoolAddress5({
+      factory,
+      tokenA: position.token0,
+      tokenB: position.token1,
+      fee: position.fee,
+      initCodeHash: V3_POOL_INIT_CODE_HASH5
+    });
+    const [poolState, ticks, globals] = await Promise.all([
+      readPoolState(params.publicClient, pool),
+      readTicksAt(params.publicClient, pool, position.tickLower, position.tickUpper),
+      readFeeGrowthGlobals(params.publicClient, pool)
+    ]);
+    const feeGrowthInside0 = computeFeeGrowthInside({
+      currentTick: poolState.tick,
+      tickLower: position.tickLower,
+      tickUpper: position.tickUpper,
+      feeGrowthGlobalX128: globals.feeGrowthGlobal0X128,
+      feeGrowthOutsideLowerX128: ticks.lower.feeGrowthOutside0X128,
+      feeGrowthOutsideUpperX128: ticks.upper.feeGrowthOutside0X128
+    });
+    const feeGrowthInside1 = computeFeeGrowthInside({
+      currentTick: poolState.tick,
+      tickLower: position.tickLower,
+      tickUpper: position.tickUpper,
+      feeGrowthGlobalX128: globals.feeGrowthGlobal1X128,
+      feeGrowthOutsideLowerX128: ticks.lower.feeGrowthOutside1X128,
+      feeGrowthOutsideUpperX128: ticks.upper.feeGrowthOutside1X128
+    });
+    const pending0 = wrappingDelta(
+      feeGrowthInside0,
+      position.feeGrowthInside0LastX128
+    ) * position.liquidity / (1n << 128n);
+    const pending1 = wrappingDelta(
+      feeGrowthInside1,
+      position.feeGrowthInside1LastX128
+    ) * position.liquidity / (1n << 128n);
+    amount0Expected += pending0;
+    amount1Expected += pending1;
+  }
+  const recipient = params.recipient ?? params.userAddress;
+  const operations = [buildCollect({ npm, tokenId: params.tokenId, recipient })];
+  const partial = buildPartialUserOperation6({
+    sender: params.userAddress,
+    nonce: 0n,
+    operations
+  });
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: partial.callData
+  });
+  let receipt;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      params.onWarning?.(
+        `collectFeesDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    amount0Expected,
+    amount1Expected,
+    recipient
+  };
+}
+function computeFeeGrowthInside(params) {
+  const {
+    currentTick,
+    tickLower,
+    tickUpper,
+    feeGrowthGlobalX128,
+    feeGrowthOutsideLowerX128,
+    feeGrowthOutsideUpperX128
+  } = params;
+  let feeGrowthBelow;
+  if (currentTick >= tickLower) {
+    feeGrowthBelow = feeGrowthOutsideLowerX128;
+  } else {
+    feeGrowthBelow = wrappingDelta(feeGrowthGlobalX128, feeGrowthOutsideLowerX128);
+  }
+  let feeGrowthAbove;
+  if (currentTick < tickUpper) {
+    feeGrowthAbove = feeGrowthOutsideUpperX128;
+  } else {
+    feeGrowthAbove = wrappingDelta(feeGrowthGlobalX128, feeGrowthOutsideUpperX128);
+  }
+  return wrappingDelta(
+    wrappingDelta(feeGrowthGlobalX128, feeGrowthBelow),
+    feeGrowthAbove
+  );
+}
+function wrappingDelta(a, b) {
+  const TWO_256 = 1n << 256n;
+  return (a - b + TWO_256) % TWO_256;
+}
 export {
+  CALLDATA_BYTES_PER_CALL,
+  LiquidityCurveError,
+  LiquidityCurveErrorCode,
+  MAX_SQRT_RATIO,
+  MAX_TICK,
+  MIN_SQRT_RATIO,
+  MIN_TICK,
   PAFI_SUBGRAPH_URL,
+  Q192,
+  Q96,
   TradingHandlers,
+  UINT128_MAX2 as UINT128_MAX,
+  V3_NPM_ADDRESSES,
   V3_SWAP_EXACT_IN,
   V3_SWAP_EXACT_OUT,
+  addLiquidityDirect,
+  applyMintSlippage,
+  applyRemoveSlippage,
+  bitmapWordRange,
   buildAllPaths,
+  buildBurn,
+  buildClosePosition,
+  buildCollect,
+  buildDecreaseLiquidity,
   buildErc20ApprovalCalldata,
+  buildIncreaseLiquidity,
+  buildLiquidityCurve,
+  buildMint,
   buildPermit2ApprovalCalldata,
   buildSwapUserOp,
   buildSwapUserOpExactOut,
@@ -1536,19 +3555,48 @@ export {
   buildV3SwapInputExactIn,
   buildV3SwapInputExactOut,
   checkAllowance,
+  clipCurveToTickRange,
+  closePositionDirect,
+  collectFeesDirect,
   combineRoutes,
+  decodeBitmapWord,
+  estimateLiquidityFromOneSide,
+  fetchAllInitializedTicks,
+  fetchLiquidityCurve,
   fetchPafiPools,
   findBestQuote,
   findBestQuoteExactOut,
+  getAmount0ForLiquidity,
+  getAmount1ForLiquidity,
+  getAmountsForLiquidity,
+  getLiquidityForAmount0,
+  getLiquidityForAmount1,
+  increaseLiquidityDirect,
+  maxUsableTick,
+  minUsableTick,
+  nearestUsableTick,
+  nonfungiblePositionManagerAbi,
   perpDepositDirect,
+  priceToTick,
   quoteBestRoute,
   quoteBestRouteExactOut,
   quoteExactInput,
   quoteExactInputSingle,
   quoteExactOutput,
   quoteExactOutputSingle,
+  readFeeGrowthGlobals,
+  readPoolState,
+  readPosition,
+  readTicksAt,
+  removeLiquidityDirect,
   simulateSwap,
+  sqrtPriceX96ToTick,
   swapDirect,
-  swapDirectExactOut
+  swapDirectExactOut,
+  tickSpacingForFee,
+  tickToBitmapPosition,
+  tickToPrice,
+  tickToSqrtPriceX96,
+  v3PoolAbi
 };
 //# sourceMappingURL=index.js.map