@pafi-dev/trading 0.3.3 → 0.4.0

package/README.md

@@ -187,6 +187,99 @@ simulations.
 
 ---
 
+## Direct path — no AA, no bundler, no sponsor-relayer
+
+`v0.4.0+` ships `swapDirect()` + `perpDepositDirect()` for the FE-only
+flow where the user pays gas in ETH and broadcasts a single type-2 tx
+calling its own EIP-7702 delegated bytecode. No Pimlico API key, no
+sponsor-relayer, no PAFI infra.
+
+**Precondition:** user EOA must already be EIP-7702 delegated (run
+`delegateDirect()` from `@pafi-dev/core` first; both helpers throw a
+clear error otherwise).
+
+### `swapDirect`
+
+```ts
+import { swapDirect, fetchPafiPools } from "@pafi-dev/trading";
+import { createPublicClient, createWalletClient, custom, http, parseUnits } from "viem";
+import { base } from "viem/chains";
+
+const publicClient = createPublicClient({ chain: base, transport: http() });
+// `walletClient` from Privy embedded wallet, MetaMask, etc.
+const walletClient = createWalletClient({
+  account: wallet.address,
+  chain: base,
+  transport: custom(await wallet.getEthereumProvider()),
+});
+
+const pools = await fetchPafiPools(8453, POINT_TOKEN);
+
+const result = await swapDirect({
+  userAddress: wallet.address,
+  chainId: 8453,
+  inputTokenAddress: POINT_TOKEN,
+  outputTokenAddress: USDT,
+  amount: parseUnits("100", 18),
+  pools,
+  publicClient,
+  walletClient,
+  // optional: slippageBps, deadline, gasFeeAmountOutput, waitForReceipt
+});
+
+console.log("Swap tx:", result.txHash);
+// {
+//   txHash, receipt?, estimatedOutputAmount, minAmountOut, hops,
+//   deadline, feeAmountUsed
+// }
+```
+
+**Operator fee:** default `0n` (skip — PAFI not sponsoring this swap).
+Pass an explicit `gasFeeAmountOutput: bigint` only if you want to mirror
+the sponsored flow's fee transfer.
+
+### `perpDepositDirect`
+
+```ts
+import { perpDepositDirect } from "@pafi-dev/trading";
+
+const result = await perpDepositDirect({
+  userAddress: wallet.address,
+  chainId: 8453,
+  amount: parseUnits("10", 6), // 10 USDC
+  brokerId: "orderly",         // | "woofi_pro" | "logx"
+  publicClient,
+  walletClient,
+  // optional: maxRelayFee, gasFeeUsdc, waitForReceipt
+});
+
+// {
+//   txHash, receipt?, relayTokenFee, maxFee, netDeposit,
+//   feeAmountUsed, accountId, brokerHash, usdcAddress, relayAddress
+// }
+```
+
+The Relay still charges its own USDC fee (`Relay.quoteTokenFee`) to
+cover LayerZero `msg.value`; that's separate from PAFI's operator fee
+(which is skipped by default on the direct path).
+
+### When to use direct vs. AA path
+
+| Aspect | `swapDirect` / `perpDepositDirect` | `TradingHandlers.handleSwap` / `handlePerpDeposit` |
+| --- | --- | --- |
+| User pays gas | ETH (native) | Free (sponsor) or ETH (fallback) |
+| Bundler required | No | Yes (Pimlico) |
+| Sponsor-relayer required | No | Yes (sponsored path) |
+| Operator fee charged | Default skip | Default included |
+| Round trips | 1 (broadcast tx) | 2+ (paymaster + bundler) |
+| Precondition | EIP-7702 delegated | Same |
+
+Use direct for FE dev/test, integrations without a Pimlico key, or
+production paths where users explicitly opt to pay gas. Use AA path for
+the production gas-free UX via sponsor-relayer.
+
+---
+
 ## API reference
 
 ### `TradingHandlers`
@@ -213,6 +306,8 @@ Methods:
 - `buildPermit2ApprovalCalldata`, `buildErc20ApprovalCalldata`, `checkAllowance`
 - `simulateSwap` — `eth_call` dry-run
 - `fetchPafiPools(chainId, pointTokenAddress, subgraphUrl?)`
+- `swapDirect(params)` — FE-direct swap (no AA, user pays gas) — see "Direct path" section
+- `perpDepositDirect(params)` — FE-direct perp deposit (no AA, user pays gas)
 
 ---
 

package/dist/index.cjs

@@ -33,10 +33,12 @@ __export(index_exports, {
   combineRoutes: () => combineRoutes,
   fetchPafiPools: () => import_core10.fetchPafiPools,
   findBestQuote: () => findBestQuote,
+  perpDepositDirect: () => perpDepositDirect,
   quoteBestRoute: () => quoteBestRoute,
   quoteExactInput: () => quoteExactInput,
   quoteExactInputSingle: () => quoteExactInputSingle,
-  simulateSwap: () => simulateSwap
+  simulateSwap: () => simulateSwap,
+  swapDirect: () => swapDirect
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -788,6 +790,241 @@ async function quoteOperatorFeeOutput(provider, chainId, outputTokenAddress) {
 
 // src/pools.ts
 var import_core10 = require("@pafi-dev/core");
+
+// src/direct/swapDirect.ts
+var import_core11 = require("@pafi-dev/core");
+async function swapDirect(params) {
+  const code = await params.publicClient.getCode({
+    address: params.userAddress
+  });
+  const delegate = (0, import_core11.parseEip7702DelegatedAddress)(code);
+  if (!delegate) {
+    throw new Error(
+      `swapDirect: user ${params.userAddress} is not EIP-7702 delegated. Run \`delegateDirect()\` first (user pays a one-time delegation tx) or use the AA path via \`TradingHandlers.handleSwap()\` + sponsor-relayer.`
+    );
+  }
+  const impl = (0, import_core11.detectDelegateImpl)(delegate);
+  if (impl === "unknown") {
+    params.onWarning?.(
+      `swapDirect: user delegated to ${delegate} which is not a PAFI-recognised impl (expected ${import_core11.SIMPLE_7702_IMPL_BASE_MAINNET} or ${import_core11.BATCH_EXECUTOR_7702_IMPL}). Continuing \u2014 execute will revert if the impl doesn't expose executeBatch.`
+    );
+  }
+  const universalRouter = import_core11.UNIVERSAL_ROUTER_ADDRESSES[params.chainId];
+  if (!universalRouter) {
+    throw new Error(`swapDirect: no UniversalRouter for chainId ${params.chainId}`);
+  }
+  if (params.amount <= 0n) {
+    throw new Error("swapDirect: amount must be positive");
+  }
+  let quoteResult;
+  try {
+    quoteResult = await findBestQuote(
+      params.publicClient,
+      params.chainId,
+      params.inputTokenAddress,
+      params.outputTokenAddress,
+      params.amount,
+      params.pools ?? []
+    );
+  } catch (err) {
+    const cause = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `swapDirect: no swap path found from ${params.inputTokenAddress} to ${params.outputTokenAddress} (cause: ${cause})`
+    );
+  }
+  const hops = quoteResult.bestRoute.path.length;
+  const slippageBps = params.slippageBps ?? (hops > 1 ? 100 : 50);
+  const estimatedOutputAmount = quoteResult.bestRoute.amountOut;
+  const minAmountOut = estimatedOutputAmount * BigInt(1e4 - slippageBps) / 10000n;
+  const gasFeeAmountOutput = params.gasFeeAmountOutput ?? 0n;
+  if (gasFeeAmountOutput > 0n && minAmountOut < gasFeeAmountOutput) {
+    throw new Error(
+      `swapDirect: minAmountOut (${minAmountOut}) below operator fee (${gasFeeAmountOutput})`
+    );
+  }
+  const deadline = params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 5 * 60);
+  const { pafiFeeRecipient } = (0, import_core11.getContractAddresses)(params.chainId);
+  const userOp = buildSwapUserOp({
+    userAddress: params.userAddress,
+    aaNonce: 0n,
+    // ignored on the native-tx path; nonce comes from EOA tx count
+    inputTokenAddress: params.inputTokenAddress,
+    outputTokenAddress: params.outputTokenAddress,
+    universalRouterAddress: universalRouter,
+    amountIn: params.amount,
+    minAmountOut,
+    swapPath: quoteResult.bestRoute.path,
+    deadline,
+    gasFeeAmountOutput,
+    feeRecipient: pafiFeeRecipient
+  });
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error(
+      "swapDirect: walletClient has no account attached \u2014 cannot send tx"
+    );
+  }
+  const txHash = await params.walletClient.sendTransaction({
+    account,
+    chain: params.walletClient.chain,
+    to: params.userAddress,
+    value: 0n,
+    data: userOp.callData
+  });
+  let receipt;
+  if (params.waitForReceipt !== false) {
+    try {
+      receipt = await params.publicClient.waitForTransactionReceipt({
+        hash: txHash
+      });
+    } catch (err) {
+      params.onWarning?.(
+        `swapDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return {
+    txHash,
+    receipt,
+    estimatedOutputAmount,
+    minAmountOut,
+    hops,
+    deadline,
+    feeAmountUsed: gasFeeAmountOutput
+  };
+}
+
+// src/direct/perpDepositDirect.ts
+var import_core12 = require("@pafi-dev/core");
+async function perpDepositDirect(params) {
+  if (params.amount <= 0n) {
+    throw new Error("perpDepositDirect: amount must be positive");
+  }
+  const code = await params.publicClient.getCode({
+    address: params.userAddress
+  });
+  const delegate = (0, import_core12.parseEip7702DelegatedAddress)(code);
+  if (!delegate) {
+    throw new Error(
+      `perpDepositDirect: user ${params.userAddress} is not EIP-7702 delegated. Run \`delegateDirect()\` first or use the AA path via \`TradingHandlers.handlePerpDeposit()\` + sponsor-relayer.`
+    );
+  }
+  const impl = (0, import_core12.detectDelegateImpl)(delegate);
+  if (impl === "unknown") {
+    params.onWarning?.(
+      `perpDepositDirect: user delegated to ${delegate} (not a PAFI-recognised impl ${import_core12.SIMPLE_7702_IMPL_BASE_MAINNET} / ${import_core12.BATCH_EXECUTOR_7702_IMPL}). Continuing \u2014 execute will revert if the impl doesn't expose executeBatch.`
+    );
+  }
+  const vault = import_core12.ORDERLY_VAULT_ADDRESSES[params.chainId];
+  if (!vault) {
+    throw new Error(
+      `perpDepositDirect: no Orderly Vault for chainId ${params.chainId}`
+    );
+  }
+  const brokerHash = import_core12.BROKER_HASHES[params.brokerId];
+  if (!brokerHash) {
+    throw new Error(
+      `perpDepositDirect: unknown brokerId "${params.brokerId}"`
+    );
+  }
+  const tokenHash = import_core12.TOKEN_HASHES.USDC;
+  const [usdcAddress, brokerAllowed] = await Promise.all([
+    params.publicClient.readContract({
+      address: vault,
+      abi: import_core12.ORDERLY_VAULT_ABI,
+      functionName: "getAllowedToken",
+      args: [tokenHash]
+    }),
+    params.publicClient.readContract({
+      address: vault,
+      abi: import_core12.ORDERLY_VAULT_ABI,
+      functionName: "getAllowedBroker",
+      args: [brokerHash]
+    })
+  ]);
+  if (!brokerAllowed) {
+    throw new Error(
+      `perpDepositDirect: broker "${params.brokerId}" is not whitelisted on Orderly Vault`
+    );
+  }
+  const { orderlyRelay: relayAddress, pafiFeeRecipient } = (0, import_core12.getContractAddresses)(
+    params.chainId
+  );
+  const RELAY_FEE_FLOOR_USDC = 2000000n;
+  const percentCap = params.amount * 500n / 10000n;
+  const maxFee = params.maxRelayFee ?? (percentCap > RELAY_FEE_FLOOR_USDC ? percentCap : RELAY_FEE_FLOOR_USDC);
+  const relayRequest = {
+    token: usdcAddress,
+    receiver: params.userAddress,
+    brokerHash,
+    totalAmount: params.amount,
+    maxFee
+  };
+  const relayTokenFee = await params.publicClient.readContract({
+    address: relayAddress,
+    abi: import_core12.ORDERLY_RELAY_ABI,
+    functionName: "quoteTokenFee",
+    args: [relayRequest]
+  });
+  if (relayTokenFee > maxFee) {
+    throw new Error(
+      `perpDepositDirect: Relay tokenFee ${relayTokenFee} exceeds maxFee ${maxFee} \u2014 pass a larger \`maxRelayFee\` or increase \`amount\`.`
+    );
+  }
+  if (relayTokenFee >= params.amount) {
+    throw new Error(
+      `perpDepositDirect: deposit amount ${params.amount} below Relay fee ${relayTokenFee} \u2014 increase \`amount\`.`
+    );
+  }
+  const gasFeeUsdc = params.gasFeeUsdc ?? 0n;
+  const partial = (0, import_core12.buildPerpDepositViaRelay)({
+    userAddress: params.userAddress,
+    aaNonce: 0n,
+    // ignored on the native-tx path
+    relayAddress,
+    request: relayRequest,
+    gasFeeUsdc: gasFeeUsdc > 0n ? gasFeeUsdc : void 0,
+    gasFeeUsdcRecipient: gasFeeUsdc > 0n ? pafiFeeRecipient : void 0
+  });
+  const account = params.walletClient.account;
+  if (!account) {
+    throw new Error(
+      "perpDepositDirect: walletClient has no account attached \u2014 cannot send tx"
+    );
+  }
+  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?.(
+        `perpDepositDirect: tx ${txHash} sent but receipt fetch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const accountId = (0, import_core12.computeAccountId)(params.userAddress, brokerHash);
+  return {
+    txHash,
+    receipt,
+    relayTokenFee,
+    maxFee,
+    netDeposit: params.amount - relayTokenFee,
+    feeAmountUsed: gasFeeUsdc,
+    accountId,
+    brokerHash,
+    usdcAddress,
+    relayAddress
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PAFI_SUBGRAPH_URL,
@@ -803,9 +1040,11 @@ var import_core10 = require("@pafi-dev/core");
   combineRoutes,
   fetchPafiPools,
   findBestQuote,
+  perpDepositDirect,
   quoteBestRoute,
   quoteExactInput,
   quoteExactInputSingle,
-  simulateSwap
+  simulateSwap,
+  swapDirect
 });
 //# sourceMappingURL=index.cjs.map