@pafi-dev/trading 0.1.10 → 0.2.0

package/dist/index.js

@@ -1,8 +1,6 @@
 // src/api/handlers.ts
 import { getAddress } from "viem";
 import {
-  findBestQuote,
-  buildSwapWithGasDeduction,
   buildPerpDepositWithGasDeduction,
   buildPerpDepositViaRelay,
   ORDERLY_RELAY_ABI,
@@ -15,6 +13,329 @@ import {
   computeAccountId,
   quoteOperatorFeePt
 } from "@pafi-dev/core";
+
+// src/quoting/routes.ts
+import { COMMON_POOLS, POINT_TOKEN_POOLS } from "@pafi-dev/core";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function combineRoutes(chainId, pointTokenAddress) {
+  const commonPools = COMMON_POOLS[chainId] ?? [];
+  const pointPools = 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
+import { v4QuoterAbi } from "@pafi-dev/core";
+import { COMMON_POOLS as COMMON_POOLS2, V4_QUOTER_ADDRESSES } from "@pafi-dev/core";
+async function quoteExactInput(client, quoterAddress, exactCurrency, path, exactAmount) {
+  const [amountOut, gasEstimate] = await client.readContract({
+    address: quoterAddress,
+    abi: 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: 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: 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 ?? V4_QUOTER_ADDRESSES[chainId];
+  if (!quoter) {
+    throw new Error(`No V4 Quoter address configured for chain ${chainId}`);
+  }
+  const commonPools = COMMON_POOLS2[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
+import { encodeFunctionData } from "viem";
+import { erc20Abi } from "@pafi-dev/core";
+import { permit2Abi } from "@pafi-dev/core";
+async function checkAllowance(client, token, owner, spender) {
+  return client.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+}
+function buildErc20ApprovalCalldata(spender, amount) {
+  return encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+}
+function buildPermit2ApprovalCalldata(token, spender, amount, expiration) {
+  return encodeFunctionData({
+    abi: permit2Abi,
+    functionName: "approve",
+    args: [token, spender, amount, expiration]
+  });
+}
+
+// src/swap/universalRouter.ts
+import { encodeAbiParameters, encodePacked } from "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 = encodePacked(
+    ["uint8", "uint8", "uint8"],
+    [SWAP_EXACT_IN, SETTLE_ALL, TAKE_ALL]
+  );
+  const swapParam = 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 = encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "maxAmount", type: "uint256" }
+    ],
+    [currencyIn, amountIn]
+  );
+  const takeParam = encodeAbiParameters(
+    [
+      { name: "currency", type: "address" },
+      { name: "minAmount", type: "uint256" }
+    ],
+    [outputCurrency, minAmountOut]
+  );
+  return encodeAbiParameters(
+    [
+      { name: "actions", type: "bytes" },
+      { name: "params", type: "bytes[]" }
+    ],
+    [actions, [swapParam, settleParam, takeParam]]
+  );
+}
+function buildUniversalRouterExecuteArgs(currencyIn, path, amountIn, minAmountOut, outputCurrency) {
+  const commands = 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
+import { universalRouterAbi } from "@pafi-dev/core";
+import { SimulationError } from "@pafi-dev/core";
+async function simulateSwap(client, routerAddress, commands, inputs, deadline, from) {
+  try {
+    const gasEstimate = await client.estimateContractGas({
+      address: routerAddress,
+      abi: 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 SimulationError("swap", message);
+  }
+}
+
+// src/swap/buildSwap.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+import {
+  PERMIT2_ADDRESS,
+  buildPartialUserOperation,
+  erc20ApproveOp,
+  erc20TransferOp,
+  rawCallOp,
+  universalRouterAbi as universalRouterAbi2
+} from "@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 = encodeFunctionData2({
+    abi: universalRouterAbi2,
+    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 = [
+    erc20ApproveOp(params.inputTokenAddress, PERMIT2_ADDRESS, totalInputApproval),
+    rawCallOp(PERMIT2_ADDRESS, permit2ApproveData),
+    rawCallOp(params.universalRouterAddress, swapCallData)
+  ];
+  if (params.gasFeeAmount > 0n) {
+    operations.push(
+      erc20TransferOp(
+        params.inputTokenAddress,
+        params.feeRecipient,
+        params.gasFeeAmount
+      )
+    );
+  }
+  return 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;
@@ -38,29 +359,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 } = getContractAddresses(request.chainId);
-    const pointTokenAddress = getAddress(request.pointTokenAddress);
+    const inputTokenAddress = getAddress(request.inputTokenAddress);
+    const outputTokenAddress = getAddress(request.outputTokenAddress);
     const pools = request.pools ?? [];
     try {
       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"
       };
@@ -85,71 +410,74 @@ var TradingHandlers = class {
     if (request.amount <= 0n) {
       throw new Error("handleSwap: amount must be positive");
     }
-    const { usdt, pafiFeeRecipient } = getContractAddresses(request.chainId);
+    const { pafiFeeRecipient } = getContractAddresses(request.chainId);
     const universalRouter = UNIVERSAL_ROUTER_ADDRESSES[request.chainId];
     if (!universalRouter) {
       throw new Error(`handleSwap: no UniversalRouter for chainId ${request.chainId}`);
     }
-    const pointTokenAddress = getAddress(request.pointTokenAddress);
+    const inputTokenAddress = getAddress(request.inputTokenAddress);
+    const outputTokenAddress = getAddress(request.outputTokenAddress);
     const userAddress = getAddress(request.userAddress);
     const pools = request.pools ?? [];
-    const slippageBps = request.slippageBps ?? 50;
-    const gasFeePt = request.gasFeePt !== void 0 ? request.gasFeePt : await quoteOperatorFeePt({
+    const gasFeeAmount = request.gasFeeAmount !== void 0 ? request.gasFeeAmount : await quoteOperatorFeePt({
       provider: this.provider,
       chainId: request.chainId,
-      pointTokenAddress
-    });
+      pointTokenAddress: inputTokenAddress
+    }).catch(() => 0n);
     let quoteResult;
     try {
       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 = 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 ? 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
     };
   }
@@ -330,6 +658,20 @@ import { fetchPafiPools, PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
 export {
   PAFI_SUBGRAPH_URL,
   TradingHandlers,
-  fetchPafiPools
+  buildAllPaths,
+  buildErc20ApprovalCalldata,
+  buildPermit2ApprovalCalldata,
+  buildSwapFromQuote,
+  buildSwapUserOp,
+  buildUniversalRouterExecuteArgs,
+  buildV4SwapInput,
+  checkAllowance,
+  combineRoutes,
+  fetchPafiPools,
+  findBestQuote,
+  quoteBestRoute,
+  quoteExactInput,
+  quoteExactInputSingle,
+  simulateSwap
 };
 //# sourceMappingURL=index.js.map