@pafi-dev/trading 0.1.10 → 0.2.0

package/dist/index.cjs

@@ -20,15 +20,345 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  PAFI_SUBGRAPH_URL: () => import_core2.PAFI_SUBGRAPH_URL,
+  PAFI_SUBGRAPH_URL: () => import_core10.PAFI_SUBGRAPH_URL,
   TradingHandlers: () => TradingHandlers,
-  fetchPafiPools: () => import_core2.fetchPafiPools
+  buildAllPaths: () => buildAllPaths,
+  buildErc20ApprovalCalldata: () => buildErc20ApprovalCalldata,
+  buildPermit2ApprovalCalldata: () => buildPermit2ApprovalCalldata,
+  buildSwapFromQuote: () => buildSwapFromQuote,
+  buildSwapUserOp: () => buildSwapUserOp,
+  buildUniversalRouterExecuteArgs: () => buildUniversalRouterExecuteArgs,
+  buildV4SwapInput: () => buildV4SwapInput,
+  checkAllowance: () => checkAllowance,
+  combineRoutes: () => combineRoutes,
+  fetchPafiPools: () => import_core10.fetchPafiPools,
+  findBestQuote: () => findBestQuote,
+  quoteBestRoute: () => quoteBestRoute,
+  quoteExactInput: () => quoteExactInput,
+  quoteExactInputSingle: () => quoteExactInputSingle,
+  simulateSwap: () => simulateSwap
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/api/handlers.ts
-var import_viem = require("viem");
+var import_viem4 = require("viem");
+var import_core9 = require("@pafi-dev/core");
+
+// src/quoting/routes.ts
 var import_core = require("@pafi-dev/core");
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function combineRoutes(chainId, pointTokenAddress) {
+  const commonPools = import_core.COMMON_POOLS[chainId] ?? [];
+  const pointPools = import_core.POINT_TOKEN_POOLS[chainId]?.[pointTokenAddress] ?? [];
+  return [...pointPools, ...commonPools];
+}
+function buildAllPaths(pools, tokenIn, tokenOut, maxHops = 3) {
+  const results = [];
+  function dfs(currentToken, currentPath, usedPoolIndices) {
+    if (currentPath.length > maxHops) return;
+    if (currentPath.length > 0 && currentToken.toLowerCase() === tokenOut.toLowerCase()) {
+      results.push([...currentPath]);
+      return;
+    }
+    for (let i = 0; i < pools.length; i++) {
+      if (usedPoolIndices.has(i)) continue;
+      const pool = pools[i];
+      const c0 = pool.currency0.toLowerCase();
+      const c1 = pool.currency1.toLowerCase();
+      const curr = currentToken.toLowerCase();
+      let nextToken = null;
+      if (curr === c0) {
+        nextToken = pool.currency1;
+      } else if (curr === c1) {
+        nextToken = pool.currency0;
+      }
+      if (!nextToken) continue;
+      const hop = {
+        intermediateCurrency: nextToken,
+        fee: pool.fee,
+        tickSpacing: pool.tickSpacing,
+        hooks: pool.hooks ?? ZERO_ADDRESS,
+        hookData: "0x"
+      };
+      usedPoolIndices.add(i);
+      currentPath.push(hop);
+      dfs(nextToken, currentPath, usedPoolIndices);
+      currentPath.pop();
+      usedPoolIndices.delete(i);
+    }
+  }
+  dfs(tokenIn, [], /* @__PURE__ */ new Set());
+  return results;
+}
+
+// src/quoting/quote.ts
+var import_core2 = require("@pafi-dev/core");
+var import_core3 = require("@pafi-dev/core");
+async function quoteExactInput(client, quoterAddress, exactCurrency, path, exactAmount) {
+  const [amountOut, gasEstimate] = await client.readContract({
+    address: quoterAddress,
+    abi: import_core2.v4QuoterAbi,
+    functionName: "quoteExactInput",
+    args: [{ exactCurrency, path, exactAmount: BigInt(exactAmount) }]
+  });
+  return { amountOut, gasEstimate, path };
+}
+async function quoteExactInputSingle(client, quoterAddress, poolKey, zeroForOne, exactAmount, hookData) {
+  const [amountOut, gasEstimate] = await client.readContract({
+    address: quoterAddress,
+    abi: import_core2.v4QuoterAbi,
+    functionName: "quoteExactInputSingle",
+    args: [
+      {
+        poolKey,
+        zeroForOne,
+        exactAmount: BigInt(exactAmount),
+        hookData
+      }
+    ]
+  });
+  return { amountOut, gasEstimate };
+}
+async function quoteBestRoute(client, quoterAddress, exactCurrency, routes, exactAmount) {
+  const results = await client.multicall({
+    contracts: routes.map((path) => ({
+      address: quoterAddress,
+      abi: import_core2.v4QuoterAbi,
+      functionName: "quoteExactInput",
+      args: [
+        {
+          exactCurrency,
+          path,
+          exactAmount: BigInt(exactAmount)
+        }
+      ]
+    })),
+    allowFailure: true
+  });
+  const allRoutes = [];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    if (r.status === "success") {
+      const [amountOut, gasEstimate] = r.result;
+      allRoutes.push({ amountOut, gasEstimate, path: routes[i] });
+    }
+  }
+  if (allRoutes.length === 0) {
+    throw new Error("No valid routes found");
+  }
+  const bestRoute = allRoutes.reduce(
+    (best, current) => current.amountOut > best.amountOut ? current : best
+  );
+  return { bestRoute, allRoutes };
+}
+async function findBestQuote(client, chainId, tokenIn, tokenOut, exactAmount, pools = [], quoterAddress, maxHops = 3) {
+  const quoter = quoterAddress ?? import_core3.V4_QUOTER_ADDRESSES[chainId];
+  if (!quoter) {
+    throw new Error(`No V4 Quoter address configured for chain ${chainId}`);
+  }
+  const commonPools = import_core3.COMMON_POOLS[chainId] ?? [];
+  const allPools = [...pools, ...commonPools];
+  const paths = buildAllPaths(allPools, tokenIn, tokenOut, maxHops);
+  if (paths.length === 0) {
+    throw new Error(`No paths found from ${tokenIn} to ${tokenOut}`);
+  }
+  return quoteBestRoute(client, quoter, tokenIn, paths, exactAmount);
+}
+
+// src/swap/approval.ts
+var import_viem = require("viem");
+var import_core4 = require("@pafi-dev/core");
+var import_core5 = require("@pafi-dev/core");
+async function checkAllowance(client, token, owner, spender) {
+  return client.readContract({
+    address: token,
+    abi: import_core4.erc20Abi,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+}
+function buildErc20ApprovalCalldata(spender, amount) {
+  return (0, import_viem.encodeFunctionData)({
+    abi: import_core4.erc20Abi,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+}
+function buildPermit2ApprovalCalldata(token, spender, amount, expiration) {
+  return (0, import_viem.encodeFunctionData)({
+    abi: import_core5.permit2Abi,
+    functionName: "approve",
+    args: [token, spender, amount, expiration]
+  });
+}
+
+// src/swap/universalRouter.ts
+var import_viem2 = require("viem");
+var V4_SWAP = 16;
+var SWAP_EXACT_IN = 7;
+var SETTLE_ALL = 12;
+var TAKE_ALL = 15;
+var PATH_KEY_ABI_COMPONENTS = [
+  { name: "intermediateCurrency", type: "address" },
+  { name: "fee", type: "uint256" },
+  { name: "tickSpacing", type: "int24" },
+  { name: "hooks", type: "address" },
+  { name: "hookData", type: "bytes" }
+];
+var EXACT_INPUT_PARAMS_ABI = [
+  { name: "currencyIn", type: "address" },
+  {
+    name: "path",
+    type: "tuple[]",
+    components: PATH_KEY_ABI_COMPONENTS
+  },
+  { name: "amountIn", type: "uint128" },
+  { name: "amountOutMinimum", type: "uint128" }
+];
+function buildV4SwapInput(currencyIn, path, amountIn, minAmountOut, outputCurrency) {
+  const actions = (0, import_viem2.encodePacked)(
+    ["uint8", "uint8", "uint8"],
+    [SWAP_EXACT_IN, SETTLE_ALL, TAKE_ALL]
+  );
+  const swapParam = (0, import_viem2.encodeAbiParameters)(
+    [{ name: "swap", type: "tuple", components: EXACT_INPUT_PARAMS_ABI }],
+    [
+      {
+        currencyIn,
+        path: path.map((p) => ({
+          intermediateCurrency: p.intermediateCurrency,
+          fee: BigInt(p.fee),
+          tickSpacing: p.tickSpacing,
+          hooks: p.hooks,
+          hookData: p.hookData
+        })),
+        amountIn,
+        amountOutMinimum: minAmountOut
+      }
+    ]
+  );
+  const settleParam = (0, import_viem2.encodeAbiParameters)(
+    [
+      { name: "currency", type: "address" },
+      { name: "maxAmount", type: "uint256" }
+    ],
+    [currencyIn, amountIn]
+  );
+  const takeParam = (0, import_viem2.encodeAbiParameters)(
+    [
+      { name: "currency", type: "address" },
+      { name: "minAmount", type: "uint256" }
+    ],
+    [outputCurrency, minAmountOut]
+  );
+  return (0, import_viem2.encodeAbiParameters)(
+    [
+      { name: "actions", type: "bytes" },
+      { name: "params", type: "bytes[]" }
+    ],
+    [actions, [swapParam, settleParam, takeParam]]
+  );
+}
+function buildUniversalRouterExecuteArgs(currencyIn, path, amountIn, minAmountOut, outputCurrency) {
+  const commands = (0, import_viem2.encodePacked)(["uint8"], [V4_SWAP]);
+  const inputs = [
+    buildV4SwapInput(currencyIn, path, amountIn, minAmountOut, outputCurrency)
+  ];
+  return { commands, inputs };
+}
+function buildSwapFromQuote(params) {
+  return buildUniversalRouterExecuteArgs(
+    params.currencyIn,
+    params.quote.path,
+    params.amountIn,
+    params.minAmountOut,
+    params.currencyOut
+  );
+}
+
+// src/swap/simulate.ts
+var import_core6 = require("@pafi-dev/core");
+var import_core7 = require("@pafi-dev/core");
+async function simulateSwap(client, routerAddress, commands, inputs, deadline, from) {
+  try {
+    const gasEstimate = await client.estimateContractGas({
+      address: routerAddress,
+      abi: import_core6.universalRouterAbi,
+      functionName: "execute",
+      args: [commands, inputs, deadline],
+      account: from
+    });
+    return { success: true, gasEstimate };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown simulation error";
+    throw new import_core7.SimulationError("swap", message);
+  }
+}
+
+// src/swap/buildSwap.ts
+var import_viem3 = require("viem");
+var import_core8 = require("@pafi-dev/core");
+function buildSwapUserOp(params) {
+  if (params.amountIn <= 0n) {
+    throw new Error("buildSwapUserOp: amountIn must be positive");
+  }
+  if (params.minAmountOut < 0n) {
+    throw new Error("buildSwapUserOp: minAmountOut must be non-negative");
+  }
+  if (params.gasFeeAmount < 0n) {
+    throw new Error("buildSwapUserOp: gasFeeAmount must be non-negative");
+  }
+  if (params.swapPath.length === 0) {
+    throw new Error(
+      "buildSwapUserOp: swapPath must contain at least one PathKey"
+    );
+  }
+  const { commands, inputs } = buildUniversalRouterExecuteArgs(
+    params.inputTokenAddress,
+    params.swapPath,
+    params.amountIn,
+    params.minAmountOut,
+    params.outputTokenAddress
+  );
+  const swapCallData = (0, import_viem3.encodeFunctionData)({
+    abi: import_core8.universalRouterAbi,
+    functionName: "execute",
+    args: [commands, inputs, params.deadline]
+  });
+  const totalInputApproval = params.amountIn + params.gasFeeAmount;
+  const permit2ApproveData = buildPermit2ApprovalCalldata(
+    params.inputTokenAddress,
+    params.universalRouterAddress,
+    params.amountIn,
+    Number(params.deadline)
+  );
+  const operations = [
+    (0, import_core8.erc20ApproveOp)(params.inputTokenAddress, import_core8.PERMIT2_ADDRESS, totalInputApproval),
+    (0, import_core8.rawCallOp)(import_core8.PERMIT2_ADDRESS, permit2ApproveData),
+    (0, import_core8.rawCallOp)(params.universalRouterAddress, swapCallData)
+  ];
+  if (params.gasFeeAmount > 0n) {
+    operations.push(
+      (0, import_core8.erc20TransferOp)(
+        params.inputTokenAddress,
+        params.feeRecipient,
+        params.gasFeeAmount
+      )
+    );
+  }
+  return (0, import_core8.buildPartialUserOperation)({
+    sender: params.userAddress,
+    nonce: params.aaNonce,
+    operations,
+    gasLimits: {
+      callGasLimit: params.gasLimits?.callGasLimit ?? 700000n,
+      verificationGasLimit: params.gasLimits?.verificationGasLimit ?? 150000n,
+      preVerificationGas: params.gasLimits?.preVerificationGas ?? 50000n
+    }
+  });
+}
+
+// src/api/handlers.ts
 var TradingHandlers = class {
   provider;
   chainId;
@@ -52,29 +382,33 @@ var TradingHandlers = class {
       throw new Error(`handleQuote: unsupported chainId ${request.chainId}`);
     }
     if (request.amount === 0n) {
-      return { pointAmount: 0n, estimatedUsdtOut: 0n, gasEstimate: 0n };
+      return {
+        inputAmount: 0n,
+        estimatedOutputAmount: 0n,
+        gasEstimate: 0n
+      };
     }
-    const { usdt } = (0, import_core.getContractAddresses)(request.chainId);
-    const pointTokenAddress = (0, import_viem.getAddress)(request.pointTokenAddress);
+    const inputTokenAddress = (0, import_viem4.getAddress)(request.inputTokenAddress);
+    const outputTokenAddress = (0, import_viem4.getAddress)(request.outputTokenAddress);
     const pools = request.pools ?? [];
     try {
-      const best = await (0, import_core.findBestQuote)(
+      const best = await findBestQuote(
         this.provider,
         request.chainId,
-        pointTokenAddress,
-        usdt,
+        inputTokenAddress,
+        outputTokenAddress,
         request.amount,
         pools
       );
       return {
-        pointAmount: request.amount,
-        estimatedUsdtOut: best.bestRoute.amountOut,
+        inputAmount: request.amount,
+        estimatedOutputAmount: best.bestRoute.amountOut,
         gasEstimate: best.bestRoute.gasEstimate
       };
     } catch {
       return {
-        pointAmount: request.amount,
-        estimatedUsdtOut: 0n,
+        inputAmount: request.amount,
+        estimatedOutputAmount: 0n,
         gasEstimate: 0n,
         quoteError: "QUOTE_UNAVAILABLE"
       };
@@ -99,71 +433,74 @@ var TradingHandlers = class {
     if (request.amount <= 0n) {
       throw new Error("handleSwap: amount must be positive");
     }
-    const { usdt, pafiFeeRecipient } = (0, import_core.getContractAddresses)(request.chainId);
-    const universalRouter = import_core.UNIVERSAL_ROUTER_ADDRESSES[request.chainId];
+    const { pafiFeeRecipient } = (0, import_core9.getContractAddresses)(request.chainId);
+    const universalRouter = import_core9.UNIVERSAL_ROUTER_ADDRESSES[request.chainId];
     if (!universalRouter) {
       throw new Error(`handleSwap: no UniversalRouter for chainId ${request.chainId}`);
     }
-    const pointTokenAddress = (0, import_viem.getAddress)(request.pointTokenAddress);
-    const userAddress = (0, import_viem.getAddress)(request.userAddress);
+    const inputTokenAddress = (0, import_viem4.getAddress)(request.inputTokenAddress);
+    const outputTokenAddress = (0, import_viem4.getAddress)(request.outputTokenAddress);
+    const userAddress = (0, import_viem4.getAddress)(request.userAddress);
     const pools = request.pools ?? [];
-    const slippageBps = request.slippageBps ?? 50;
-    const gasFeePt = request.gasFeePt !== void 0 ? request.gasFeePt : await (0, import_core.quoteOperatorFeePt)({
+    const gasFeeAmount = request.gasFeeAmount !== void 0 ? request.gasFeeAmount : await (0, import_core9.quoteOperatorFeePt)({
       provider: this.provider,
       chainId: request.chainId,
-      pointTokenAddress
-    });
+      pointTokenAddress: inputTokenAddress
+    }).catch(() => 0n);
     let quoteResult;
     try {
-      quoteResult = await (0, import_core.findBestQuote)(
+      quoteResult = await findBestQuote(
         this.provider,
         request.chainId,
-        pointTokenAddress,
-        usdt,
+        inputTokenAddress,
+        outputTokenAddress,
         request.amount,
         pools
       );
     } catch {
-      throw new Error("handleSwap: no swap path found for this point token");
+      throw new Error(
+        `handleSwap: no swap path found from ${inputTokenAddress} to ${outputTokenAddress}`
+      );
     }
-    const estimatedUsdtOut = quoteResult.bestRoute.amountOut;
-    const minAmountOut = estimatedUsdtOut * BigInt(1e4 - slippageBps) / 10000n;
+    const hops = quoteResult.bestRoute.path.length;
+    const slippageBps = request.slippageBps ?? (hops > 1 ? 100 : 50);
+    const estimatedOutputAmount = quoteResult.bestRoute.amountOut;
+    const minAmountOut = estimatedOutputAmount * BigInt(1e4 - slippageBps) / 10000n;
     const deadline = BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
-    const userOp = (0, import_core.buildSwapWithGasDeduction)({
+    const userOp = buildSwapUserOp({
       userAddress,
       aaNonce: request.aaNonce,
-      pointTokenAddress,
-      outputTokenAddress: usdt,
+      inputTokenAddress,
+      outputTokenAddress,
       universalRouterAddress: universalRouter,
       amountIn: request.amount,
       minAmountOut,
       swapPath: quoteResult.bestRoute.path,
       deadline,
-      gasFeePt,
-      // Recipient is always PAFI's canonical address — sponsor-relayer's
-      // L1 gate will reject any other recipient anyway. No override.
+      gasFeeAmount,
       feeRecipient: pafiFeeRecipient
     });
-    const userOpFallback = gasFeePt > 0n ? (0, import_core.buildSwapWithGasDeduction)({
+    const userOpFallback = gasFeeAmount > 0n ? buildSwapUserOp({
       userAddress,
       aaNonce: request.aaNonce,
-      pointTokenAddress,
-      outputTokenAddress: usdt,
+      inputTokenAddress,
+      outputTokenAddress,
       universalRouterAddress: universalRouter,
       amountIn: request.amount,
       minAmountOut,
       swapPath: quoteResult.bestRoute.path,
       deadline,
-      gasFeePt: 0n,
-      feeRecipient: userAddress
+      gasFeeAmount: 0n,
+      feeRecipient: pafiFeeRecipient
     }) : void 0;
     return {
       userOp,
       userOpFallback,
-      estimatedUsdtOut,
+      estimatedOutputAmount,
       minAmountOut,
+      hops,
       deadline,
-      feeAmountUsed: gasFeePt,
+      feeAmountUsed: gasFeeAmount,
       feeRecipient: pafiFeeRecipient
     };
   }
@@ -195,26 +532,26 @@ var TradingHandlers = class {
     if (request.amount <= 0n) {
       throw new Error("handlePerpDeposit: amount must be positive");
     }
-    const vault = import_core.ORDERLY_VAULT_ADDRESSES[request.chainId];
+    const vault = import_core9.ORDERLY_VAULT_ADDRESSES[request.chainId];
     if (!vault) {
       throw new Error(`handlePerpDeposit: no Orderly Vault for chainId ${request.chainId}`);
     }
-    const brokerHash = import_core.BROKER_HASHES[request.brokerId];
+    const brokerHash = import_core9.BROKER_HASHES[request.brokerId];
     if (!brokerHash) {
       throw new Error(`handlePerpDeposit: unknown brokerId "${request.brokerId}"`);
     }
-    const tokenHash = import_core.TOKEN_HASHES.USDC;
-    const userAddress = (0, import_viem.getAddress)(request.userAddress);
+    const tokenHash = import_core9.TOKEN_HASHES.USDC;
+    const userAddress = (0, import_viem4.getAddress)(request.userAddress);
     const [usdcAddress, brokerAllowed] = await Promise.all([
       this.provider.readContract({
         address: vault,
-        abi: import_core.ORDERLY_VAULT_ABI,
+        abi: import_core9.ORDERLY_VAULT_ABI,
         functionName: "getAllowedToken",
         args: [tokenHash]
       }),
       this.provider.readContract({
         address: vault,
-        abi: import_core.ORDERLY_VAULT_ABI,
+        abi: import_core9.ORDERLY_VAULT_ABI,
         functionName: "getAllowedBroker",
         args: [brokerHash]
       })
@@ -224,7 +561,7 @@ var TradingHandlers = class {
         `handlePerpDeposit: broker "${request.brokerId}" is not whitelisted on Orderly Vault`
       );
     }
-    const accountId = (0, import_core.computeAccountId)(userAddress, brokerHash);
+    const accountId = (0, import_core9.computeAccountId)(userAddress, brokerHash);
     const depositData = {
       accountId,
       brokerHash,
@@ -233,17 +570,17 @@ var TradingHandlers = class {
     };
     const layerZeroFee = await this.provider.readContract({
       address: vault,
-      abi: import_core.ORDERLY_VAULT_ABI,
+      abi: import_core9.ORDERLY_VAULT_ABI,
       functionName: "getDepositFee",
       args: [userAddress, depositData]
     });
     const useRelay = request.viaRelay !== false;
-    const { orderlyRelay: relayAddress, pafiFeeRecipient } = (0, import_core.getContractAddresses)(request.chainId);
+    const { orderlyRelay: relayAddress, pafiFeeRecipient } = (0, import_core9.getContractAddresses)(request.chainId);
     const relayDeployed = !isPlaceholderAddress(relayAddress);
-    const gasFeePt = request.gasFeePt !== void 0 ? request.gasFeePt : useRelay && relayDeployed && request.pointTokenAddress ? await (0, import_core.quoteOperatorFeePt)({
+    const gasFeePt = request.gasFeePt !== void 0 ? request.gasFeePt : useRelay && relayDeployed && request.pointTokenAddress ? await (0, import_core9.quoteOperatorFeePt)({
       provider: this.provider,
       chainId: request.chainId,
-      pointTokenAddress: (0, import_viem.getAddress)(request.pointTokenAddress)
+      pointTokenAddress: (0, import_viem4.getAddress)(request.pointTokenAddress)
     }) : 0n;
     if (useRelay && relayDeployed) {
       const RELAY_FEE_FLOOR_USDC = 2000000n;
@@ -258,7 +595,7 @@ var TradingHandlers = class {
       };
       const relayTokenFee = await this.provider.readContract({
         address: relayAddress,
-        abi: import_core.ORDERLY_RELAY_ABI,
+        abi: import_core9.ORDERLY_RELAY_ABI,
         functionName: "quoteTokenFee",
         args: [relayRequest]
       });
@@ -274,7 +611,7 @@ var TradingHandlers = class {
           `handlePerpDeposit: deposit amount ${amountUsdc} USDC is below the Relay fee ${feeUsdc} USDC \u2014 increase \`amount\` to at least ${(feeUsdc * 2).toFixed(6)} USDC so a meaningful balance reaches your Orderly account after the Relay charge.`
         );
       }
-      const userOp2 = (0, import_core.buildPerpDepositViaRelay)({
+      const userOp2 = (0, import_core9.buildPerpDepositViaRelay)({
         userAddress,
         aaNonce: request.aaNonce,
         relayAddress,
@@ -288,7 +625,7 @@ var TradingHandlers = class {
         gasFeePt: gasFeePt > 0n ? gasFeePt : void 0,
         gasFeePtRecipient: gasFeePt > 0n ? pafiFeeRecipient : void 0
       });
-      const userOpFallback = gasFeePt > 0n ? (0, import_core.buildPerpDepositViaRelay)({
+      const userOpFallback = gasFeePt > 0n ? (0, import_core9.buildPerpDepositViaRelay)({
         userAddress,
         aaNonce: request.aaNonce,
         relayAddress,
@@ -308,7 +645,7 @@ var TradingHandlers = class {
         feeRecipient: pafiFeeRecipient
       };
     }
-    const userOp = (0, import_core.buildPerpDepositWithGasDeduction)({
+    const userOp = (0, import_core9.buildPerpDepositWithGasDeduction)({
       userAddress,
       aaNonce: request.aaNonce,
       chainId: request.chainId,
@@ -340,11 +677,25 @@ function isPlaceholderAddress(addr) {
 }
 
 // src/pools.ts
-var import_core2 = require("@pafi-dev/core");
+var import_core10 = require("@pafi-dev/core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PAFI_SUBGRAPH_URL,
   TradingHandlers,
-  fetchPafiPools
+  buildAllPaths,
+  buildErc20ApprovalCalldata,
+  buildPermit2ApprovalCalldata,
+  buildSwapFromQuote,
+  buildSwapUserOp,
+  buildUniversalRouterExecuteArgs,
+  buildV4SwapInput,
+  checkAllowance,
+  combineRoutes,
+  fetchPafiPools,
+  findBestQuote,
+  quoteBestRoute,
+  quoteExactInput,
+  quoteExactInputSingle,
+  simulateSwap
 });
 //# sourceMappingURL=index.cjs.map