@pafi-dev/trading 0.3.3 → 0.4.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Address, PublicClient, Hex } from 'viem';
-import { PartialUserOperation, PoolKey, QuoteResult, PathKey, BestQuote } from '@pafi-dev/core';
+import { Address, PublicClient, Hex, WalletClient, TransactionReceipt } from 'viem';
+import { PartialUserOperation, PoolKey, QuoteResult, PathKey, BestQuote, BROKER_HASHES } from '@pafi-dev/core';
 export { PAFI_SUBGRAPH_URL, fetchPafiPools } from '@pafi-dev/core';
 
 interface ApiQuoteRequest {
@@ -508,4 +508,179 @@ declare function quoteBestRoute(client: PublicClient, quoterAddress: Address, ex
  */
 declare function findBestQuote(client: PublicClient, chainId: number, tokenIn: Address, tokenOut: Address, exactAmount: bigint, pools?: PoolKey[], quoterAddress?: Address, maxHops?: number): Promise<BestQuote>;
 
-export { type ApiPerpDepositRequest, type ApiPerpDepositResponse, type ApiQuoteError, type ApiQuoteRequest, type ApiQuoteResponse, type ApiSwapRequest, type ApiSwapResponse, type BuildSwapUserOpParams, type SwapSimulationResult, TradingHandlers, type TradingHandlersConfig, buildAllPaths, buildErc20ApprovalCalldata, buildPermit2ApprovalCalldata, buildSwapFromQuote, buildSwapUserOp, buildUniversalRouterExecuteArgs, buildV4SwapInput, checkAllowance, combineRoutes, findBestQuote, quoteBestRoute, quoteExactInput, quoteExactInputSingle, simulateSwap };
+interface SwapDirectParams {
+    /** User EOA — must be delegated via EIP-7702 to a PAFI-supported impl. */
+    userAddress: Address;
+    chainId: number;
+    inputTokenAddress: Address;
+    outputTokenAddress: Address;
+    /** Input amount (raw token decimals). */
+    amount: bigint;
+    /** Pools to route through. Caller pre-fetches via `fetchPafiPools`. */
+    pools?: PoolKey[];
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+    /**
+     * Slippage tolerance in basis points. Default 50 single-hop / 100
+     * multi-hop (handler picks based on `bestRoute.path.length`).
+     */
+    slippageBps?: number;
+    /** Swap deadline (unix seconds). Default = now + 5 minutes. */
+    deadline?: bigint;
+    /**
+     * Operator fee in OUTPUT token, paid to PAFI fee recipient.
+     *
+     * - `undefined` (default for direct path): **skip the fee transfer
+     *   entirely** — PAFI is not sponsoring this swap, no reimbursement
+     *   owed. Most callers want this.
+     * - `0n` — same as above, explicit.
+     * - explicit `bigint` — include the fee transfer (rare; only when
+     *   issuer dev/test wants to mirror sponsored behaviour).
+     */
+    gasFeeAmountOutput?: bigint;
+    /** Wait for receipt before returning. Default `true`. */
+    waitForReceipt?: boolean;
+    onWarning?: (msg: string) => void;
+}
+interface SwapDirectResult {
+    txHash: Hex;
+    receipt?: TransactionReceipt;
+    estimatedOutputAmount: bigint;
+    minAmountOut: bigint;
+    hops: number;
+    deadline: bigint;
+    feeAmountUsed: bigint;
+}
+/**
+ * One-shot helper for the **FE-direct swap** path — no AA, no bundler,
+ * no PAFI sponsor-relayer. The user EOA pays gas in ETH and broadcasts
+ * a single type-2 transaction calling its own EIP-7702 delegated
+ * bytecode (`Simple7702Account.executeBatch`).
+ *
+ * Flow:
+ *   1. Verify the EOA has EIP-7702 delegation to a PAFI-supported impl
+ *      (Simple7702Account or Coinbase SW v2 BatchExecutor). Throw with
+ *      a clear hint pointing at `delegateDirect()` if not delegated.
+ *   2. `findBestQuote` → best route + gross output.
+ *   3. `buildSwapUserOp` → encoded `executeBatch(calls)` calldata.
+ *   4. `walletClient.sendTransaction({ to: userAddress, data: callData })`
+ *      — self-call into the delegated bytecode, which dispatches the
+ *      batch (input.approve → Permit2.approve → UR.execute → optional
+ *      fee transfer).
+ *   5. Wait for receipt (optional).
+ *
+ * Use when:
+ *   - The FE doesn't have a Pimlico API key + doesn't want to depend on
+ *     PAFI sponsor-relayer.
+ *   - The user already has a small ETH balance.
+ *   - You need a deterministic, single-tx swap (vs. AA UserOp's longer
+ *     bundler round-trip).
+ *
+ * Throws when the user is NOT yet delegated — caller should run
+ * `delegateDirect` first or use the AA path (`TradingHandlers.handleSwap`
+ * + `permissionless`).
+ *
+ * @example
+ * ```ts
+ * import { swapDirect, fetchPafiPools } from "@pafi-dev/trading";
+ *
+ * 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,
+ * });
+ * console.log("Swap tx:", result.txHash);
+ * ```
+ */
+declare function swapDirect(params: SwapDirectParams): Promise<SwapDirectResult>;
+
+interface PerpDepositDirectParams {
+    /** User EOA — must be EIP-7702 delegated. */
+    userAddress: Address;
+    chainId: number;
+    /** USDC amount to deposit (6-decimal raw units). */
+    amount: bigint;
+    /** Orderly broker — `'orderly' | 'woofi_pro' | 'logx'`. */
+    brokerId: keyof typeof BROKER_HASHES;
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+    /**
+     * Max acceptable USDC fee charged by the Relay (slippage cap on its
+     * USD-pricing of `msg.value`). Default `max(amount * 5%, 2 USDC)` —
+     * matches `TradingHandlers.handlePerpDeposit`.
+     */
+    maxRelayFee?: bigint;
+    /**
+     * Operator fee in USDC (input-token, BEFORE deposit). Same semantics
+     * as `swapDirect.gasFeeAmountOutput`:
+     *
+     * - `undefined` (default for direct path): **skip the fee transfer**
+     *   — PAFI is not sponsoring this deposit.
+     * - explicit `bigint` — include the fee transfer.
+     */
+    gasFeeUsdc?: bigint;
+    /** Wait for receipt before returning. Default `true`. */
+    waitForReceipt?: boolean;
+    onWarning?: (msg: string) => void;
+}
+interface PerpDepositDirectResult {
+    txHash: Hex;
+    receipt?: TransactionReceipt;
+    /** Resolved USDC fee charged by the Relay. */
+    relayTokenFee: bigint;
+    /** Cap applied to the Relay fee (slippage allowance). */
+    maxFee: bigint;
+    /** USDC reaching Orderly Vault after Relay's fee = amount - relayTokenFee. */
+    netDeposit: bigint;
+    /** Operator fee actually included (0n on default direct path). */
+    feeAmountUsed: bigint;
+    accountId: Hex;
+    brokerHash: Hex;
+    usdcAddress: Address;
+    relayAddress: Address;
+}
+/**
+ * One-shot helper for the **FE-direct perp deposit** path — no AA, no
+ * bundler, no PAFI sponsor-relayer. The user EOA pays gas in ETH and
+ * broadcasts a single type-2 transaction calling its own EIP-7702
+ * delegated bytecode (`Simple7702Account.executeBatch`).
+ *
+ * Flow:
+ *   1. Verify EIP-7702 delegation (same precondition as `swapDirect`).
+ *   2. Resolve USDC + verify broker is whitelisted on Orderly Vault.
+ *   3. Quote `Relay.tokenFee` for the deposit; compute `netDeposit`.
+ *   4. `buildPerpDepositViaRelay` → encoded `executeBatch(calls)`
+ *      (USDC.approve(relay) + Relay.deposit + optional fee transfer).
+ *   5. `walletClient.sendTransaction({ to: userAddress, data: callData })`.
+ *   6. Wait for receipt (optional).
+ *
+ * Use when: same conditions as `swapDirect` — FE doesn't have Pimlico
+ * key, doesn't want sponsor-relayer dependency, user has small ETH.
+ *
+ * Throws when the user is NOT yet delegated.
+ *
+ * @example
+ * ```ts
+ * import { perpDepositDirect } from "@pafi-dev/trading";
+ *
+ * const result = await perpDepositDirect({
+ *   userAddress: wallet.address,
+ *   chainId: 8453,
+ *   amount: parseUnits("10", 6), // 10 USDC
+ *   brokerId: "orderly",
+ *   publicClient,
+ *   walletClient,
+ * });
+ * console.log("Deposit tx:", result.txHash);
+ * console.log("Net deposit to Orderly:", result.netDeposit, "USDC raw");
+ * ```
+ */
+declare function perpDepositDirect(params: PerpDepositDirectParams): Promise<PerpDepositDirectResult>;
+
+export { type ApiPerpDepositRequest, type ApiPerpDepositResponse, type ApiQuoteError, type ApiQuoteRequest, type ApiQuoteResponse, type ApiSwapRequest, type ApiSwapResponse, type BuildSwapUserOpParams, type PerpDepositDirectParams, type PerpDepositDirectResult, type SwapDirectParams, type SwapDirectResult, type SwapSimulationResult, TradingHandlers, type TradingHandlersConfig, buildAllPaths, buildErc20ApprovalCalldata, buildPermit2ApprovalCalldata, buildSwapFromQuote, buildSwapUserOp, buildUniversalRouterExecuteArgs, buildV4SwapInput, checkAllowance, combineRoutes, findBestQuote, perpDepositDirect, quoteBestRoute, quoteExactInput, quoteExactInputSingle, simulateSwap, swapDirect };

package/dist/index.js

@@ -767,6 +767,261 @@ async function quoteOperatorFeeOutput(provider, chainId, outputTokenAddress) {
 
 // src/pools.ts
 import { fetchPafiPools, PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
+
+// src/direct/swapDirect.ts
+import {
+  UNIVERSAL_ROUTER_ADDRESSES as UNIVERSAL_ROUTER_ADDRESSES2,
+  getContractAddresses as getContractAddresses2,
+  parseEip7702DelegatedAddress,
+  detectDelegateImpl,
+  SIMPLE_7702_IMPL_BASE_MAINNET,
+  BATCH_EXECUTOR_7702_IMPL
+} from "@pafi-dev/core";
+async function swapDirect(params) {
+  const code = await params.publicClient.getCode({
+    address: params.userAddress
+  });
+  const delegate = 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 = detectDelegateImpl(delegate);
+  if (impl === "unknown") {
+    params.onWarning?.(
+      `swapDirect: user delegated to ${delegate} which is not a PAFI-recognised impl (expected ${SIMPLE_7702_IMPL_BASE_MAINNET} or ${BATCH_EXECUTOR_7702_IMPL}). Continuing \u2014 execute will revert if the impl doesn't expose executeBatch.`
+    );
+  }
+  const universalRouter = UNIVERSAL_ROUTER_ADDRESSES2[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 } = getContractAddresses2(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
+import {
+  BROKER_HASHES as BROKER_HASHES2,
+  ORDERLY_RELAY_ABI as ORDERLY_RELAY_ABI2,
+  ORDERLY_VAULT_ABI as ORDERLY_VAULT_ABI2,
+  ORDERLY_VAULT_ADDRESSES as ORDERLY_VAULT_ADDRESSES2,
+  TOKEN_HASHES as TOKEN_HASHES2,
+  buildPerpDepositViaRelay as buildPerpDepositViaRelay2,
+  computeAccountId as computeAccountId2,
+  detectDelegateImpl as detectDelegateImpl2,
+  getContractAddresses as getContractAddresses3,
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress2,
+  BATCH_EXECUTOR_7702_IMPL as BATCH_EXECUTOR_7702_IMPL2,
+  SIMPLE_7702_IMPL_BASE_MAINNET as SIMPLE_7702_IMPL_BASE_MAINNET2
+} from "@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 = parseEip7702DelegatedAddress2(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 = detectDelegateImpl2(delegate);
+  if (impl === "unknown") {
+    params.onWarning?.(
+      `perpDepositDirect: user delegated to ${delegate} (not a PAFI-recognised impl ${SIMPLE_7702_IMPL_BASE_MAINNET2} / ${BATCH_EXECUTOR_7702_IMPL2}). Continuing \u2014 execute will revert if the impl doesn't expose executeBatch.`
+    );
+  }
+  const vault = ORDERLY_VAULT_ADDRESSES2[params.chainId];
+  if (!vault) {
+    throw new Error(
+      `perpDepositDirect: no Orderly Vault for chainId ${params.chainId}`
+    );
+  }
+  const brokerHash = BROKER_HASHES2[params.brokerId];
+  if (!brokerHash) {
+    throw new Error(
+      `perpDepositDirect: unknown brokerId "${params.brokerId}"`
+    );
+  }
+  const tokenHash = TOKEN_HASHES2.USDC;
+  const [usdcAddress, brokerAllowed] = await Promise.all([
+    params.publicClient.readContract({
+      address: vault,
+      abi: ORDERLY_VAULT_ABI2,
+      functionName: "getAllowedToken",
+      args: [tokenHash]
+    }),
+    params.publicClient.readContract({
+      address: vault,
+      abi: ORDERLY_VAULT_ABI2,
+      functionName: "getAllowedBroker",
+      args: [brokerHash]
+    })
+  ]);
+  if (!brokerAllowed) {
+    throw new Error(
+      `perpDepositDirect: broker "${params.brokerId}" is not whitelisted on Orderly Vault`
+    );
+  }
+  const { orderlyRelay: relayAddress, pafiFeeRecipient } = getContractAddresses3(
+    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: ORDERLY_RELAY_ABI2,
+    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 = buildPerpDepositViaRelay2({
+    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 = computeAccountId2(params.userAddress, brokerHash);
+  return {
+    txHash,
+    receipt,
+    relayTokenFee,
+    maxFee,
+    netDeposit: params.amount - relayTokenFee,
+    feeAmountUsed: gasFeeUsdc,
+    accountId,
+    brokerHash,
+    usdcAddress,
+    relayAddress
+  };
+}
 export {
   PAFI_SUBGRAPH_URL,
   TradingHandlers,
@@ -781,9 +1036,11 @@ export {
   combineRoutes,
   fetchPafiPools,
   findBestQuote,
+  perpDepositDirect,
   quoteBestRoute,
   quoteExactInput,
   quoteExactInputSingle,
-  simulateSwap
+  simulateSwap,
+  swapDirect
 };
 //# sourceMappingURL=index.js.map