@pafi-dev/issuer 0.5.33 → 0.5.35

package/dist/index.js

@@ -1698,6 +1698,683 @@ async function handleRedeemStatus(params) {
   };
 }
 
+// src/api/mobileHandlers.ts
+import {
+  ENTRY_POINT_V08,
+  parseEip7702DelegatedAddress
+} from "@pafi-dev/core";
+
+// src/userop-store/serialize.ts
+import { serializeUserOpToJsonRpc } from "@pafi-dev/core";
+function serializeEntryToJsonRpc(entry, signature, variant = "sponsored") {
+  if (variant === "fallback") {
+    if (!entry.fallback) {
+      throw new Error(
+        "serializeEntryToJsonRpc: variant=fallback requested but the stored entry has no `fallback` branch \u2014 caller should resubmit with variant='sponsored' or re-prepare with a fee configured."
+      );
+    }
+    return serializeUserOpToJsonRpc(
+      {
+        sender: entry.sender,
+        nonce: BigInt(entry.nonce),
+        callData: entry.fallback.callData,
+        callGasLimit: BigInt(entry.fallback.callGasLimit),
+        verificationGasLimit: BigInt(entry.fallback.verificationGasLimit),
+        preVerificationGas: BigInt(entry.fallback.preVerificationGas),
+        maxFeePerGas: BigInt(entry.maxFeePerGas),
+        maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas)
+        // intentionally no paymaster — user pays ETH gas
+      },
+      signature
+    );
+  }
+  return serializeUserOpToJsonRpc(
+    {
+      sender: entry.sender,
+      nonce: BigInt(entry.nonce),
+      callData: entry.callData,
+      callGasLimit: BigInt(entry.callGasLimit),
+      verificationGasLimit: BigInt(entry.verificationGasLimit),
+      preVerificationGas: BigInt(entry.preVerificationGas),
+      maxFeePerGas: BigInt(entry.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas),
+      paymaster: entry.paymaster,
+      paymasterVerificationGasLimit: entry.paymasterVerificationGasLimit != null ? BigInt(entry.paymasterVerificationGasLimit) : void 0,
+      paymasterPostOpGasLimit: entry.paymasterPostOpGasLimit != null ? BigInt(entry.paymasterPostOpGasLimit) : void 0,
+      paymasterData: entry.paymasterData
+    },
+    signature
+  );
+}
+
+// src/userop-store/prepareUserOp.ts
+import {
+  buildUserOpTypedData,
+  computeUserOpHash
+} from "@pafi-dev/core";
+function serializeUserOpTypedData(td) {
+  return {
+    domain: td.domain,
+    types: td.types,
+    primaryType: td.primaryType,
+    message: {
+      sender: td.message.sender,
+      nonce: `0x${td.message.nonce.toString(16)}`,
+      initCode: td.message.initCode,
+      callData: td.message.callData,
+      accountGasLimits: td.message.accountGasLimits,
+      preVerificationGas: `0x${td.message.preVerificationGas.toString(
+        16
+      )}`,
+      gasFees: td.message.gasFees,
+      paymasterAndData: td.message.paymasterAndData
+    }
+  };
+}
+function mergePaymasterFields(userOp, paymasterFields) {
+  if (!paymasterFields) return userOp;
+  const merged = {
+    ...userOp
+  };
+  for (const [k, v] of Object.entries(paymasterFields)) {
+    if (v !== void 0) merged[k] = v;
+  }
+  return merged;
+}
+async function prepareMobileUserOp(params) {
+  const userOp = mergePaymasterFields(
+    params.partialUserOp,
+    params.paymasterFields
+  );
+  const userOpHash = computeUserOpHash(userOp, params.chainId);
+  const typedData = serializeUserOpTypedData(
+    buildUserOpTypedData(userOp, params.chainId)
+  );
+  let fallback;
+  let fallbackEntry;
+  if (params.partialUserOpFallback) {
+    const fallbackUserOp = {
+      ...params.partialUserOpFallback,
+      maxFeePerGas: userOp.maxFeePerGas,
+      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
+    };
+    const fallbackHash = computeUserOpHash(fallbackUserOp, params.chainId);
+    const fallbackTypedData = serializeUserOpTypedData(
+      buildUserOpTypedData(fallbackUserOp, params.chainId)
+    );
+    fallback = {
+      userOp: fallbackUserOp,
+      userOpHash: fallbackHash,
+      typedData: fallbackTypedData
+    };
+    fallbackEntry = {
+      callData: fallbackUserOp.callData,
+      callGasLimit: fallbackUserOp.callGasLimit.toString(),
+      verificationGasLimit: fallbackUserOp.verificationGasLimit.toString(),
+      preVerificationGas: fallbackUserOp.preVerificationGas.toString(),
+      userOpHash: fallbackHash
+    };
+  }
+  const entry = {
+    sender: userOp.sender,
+    nonce: userOp.nonce.toString(),
+    callData: userOp.callData,
+    callGasLimit: userOp.callGasLimit.toString(),
+    verificationGasLimit: userOp.verificationGasLimit.toString(),
+    preVerificationGas: userOp.preVerificationGas.toString(),
+    maxFeePerGas: userOp.maxFeePerGas.toString(),
+    maxPriorityFeePerGas: userOp.maxPriorityFeePerGas.toString(),
+    paymaster: userOp.paymaster,
+    paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit?.toString(),
+    paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit?.toString(),
+    paymasterData: userOp.paymasterData,
+    chainId: params.chainId,
+    userOpHash,
+    fallback: fallbackEntry
+  };
+  await params.store.save(params.lockId, entry, params.ttlSeconds);
+  return {
+    sponsored: { userOp, userOpHash, typedData },
+    fallback,
+    entry
+  };
+}
+
+// src/pafi-backend/helpers.ts
+var BundlerNotConfiguredError = class extends Error {
+  code = "BUNDLER_NOT_CONFIGURED";
+  constructor() {
+    super(
+      "PAFI backend client not configured \u2014 set PAFI_BACKEND_URL, PAFI_ISSUER_ID, PAFI_API_KEY to enable mobile submit."
+    );
+    this.name = "BundlerNotConfiguredError";
+  }
+};
+var BundlerRejectedError = class extends Error {
+  code = "BUNDLER_REJECTED";
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "BundlerRejectedError";
+    this.cause = cause;
+  }
+};
+async function requestPaymaster(params) {
+  if (!params.client) return void 0;
+  const fn = params.functionName ?? defaultFunctionForScenario(params.scenario);
+  try {
+    return await params.client.requestSponsorship({
+      chainId: params.chainId,
+      scenario: params.scenario,
+      userOp: params.userOp,
+      target: {
+        contract: params.pointTokenAddress,
+        function: fn,
+        pointToken: params.pointTokenAddress
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    params.onWarning?.(`Paymaster sponsorship declined: ${msg}`);
+    return void 0;
+  }
+}
+function defaultFunctionForScenario(scenario) {
+  switch (scenario) {
+    case "mint":
+      return "mint";
+    case "burn":
+      return "burn";
+    case "swap":
+      return "swap";
+    case "perp-deposit":
+      return "deposit";
+    default:
+      return scenario;
+  }
+}
+async function relayUserOp(params) {
+  if (!params.client) {
+    throw new BundlerNotConfiguredError();
+  }
+  try {
+    const result = await params.client.relayUserOperation({
+      userOp: params.userOp,
+      entryPoint: params.entryPoint,
+      eip7702Auth: params.eip7702Auth
+    });
+    return { userOpHash: result.userOpHash };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new BundlerRejectedError(msg, err);
+  }
+}
+
+// src/api/mobileHandlers.ts
+var PendingUserOpNotFoundError = class extends Error {
+  code = "PENDING_USEROP_NOT_FOUND";
+  constructor(lockId) {
+    super(
+      `No pending UserOp found for lockId ${lockId} \u2014 it may have expired or already been submitted.`
+    );
+    this.name = "PendingUserOpNotFoundError";
+  }
+};
+async function handleMobilePrepare(params) {
+  const [fees, userCode] = await Promise.all([
+    params.provider.estimateFeesPerGas(),
+    params.provider.getCode({ address: params.userAddress })
+  ]);
+  const needsDelegation = parseEip7702DelegatedAddress(userCode) === null;
+  const sponsoredOp = {
+    ...params.partialUserOp,
+    maxFeePerGas: fees.maxFeePerGas ?? params.partialUserOp.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? params.partialUserOp.maxPriorityFeePerGas ?? 0n
+  };
+  const paymasterFields = await requestPaymaster({
+    client: params.pafiBackendClient,
+    chainId: params.chainId,
+    scenario: params.scenario,
+    userOp: sponsoredOp,
+    pointTokenAddress: params.pointTokenAddress,
+    onWarning: params.onWarning
+  });
+  const prepared = await prepareMobileUserOp({
+    lockId: params.lockId,
+    partialUserOp: sponsoredOp,
+    partialUserOpFallback: params.partialUserOpFallback,
+    paymasterFields,
+    chainId: params.chainId,
+    store: params.store,
+    ttlSeconds: params.ttlSeconds
+  });
+  return {
+    ...prepared,
+    isSponsored: !!paymasterFields,
+    needsDelegation
+  };
+}
+async function handleMobileSubmit(params) {
+  const entry = await params.store.get(params.lockId);
+  if (!entry) {
+    throw new PendingUserOpNotFoundError(params.lockId);
+  }
+  const variant = params.variant ?? "sponsored";
+  const userOpJson = serializeEntryToJsonRpc(entry, params.signature, variant);
+  const result = await relayUserOp({
+    client: params.pafiBackendClient,
+    userOp: userOpJson,
+    entryPoint: params.entryPoint ?? ENTRY_POINT_V08
+  });
+  await params.bindUserOpHash(params.lockId, result.userOpHash);
+  await params.store.delete(params.lockId);
+  return { userOpHash: result.userOpHash };
+}
+
+// src/api/handlers/ptClaimHandler.ts
+import { getAddress as getAddress8 } from "viem";
+import {
+  decodeBatchExecuteCalls,
+  getContractAddresses as getContractAddresses2
+} from "@pafi-dev/core";
+
+// src/issuer-state/types.ts
+var IssuerStateError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "IssuerStateError";
+  }
+  code;
+  details;
+};
+
+// src/api/handlers/ptClaimHandler.ts
+var PTClaimError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "PTClaimError";
+  }
+  code;
+  details;
+};
+var DEFAULT_LOCK_MS = 15 * 60 * 1e3;
+var DEFAULT_SIG_DEADLINE_SEC2 = 15 * 60;
+var PTClaimHandler = class {
+  cfg;
+  constructor(config) {
+    this.cfg = {
+      ...config,
+      lockDurationMs: config.lockDurationMs ?? DEFAULT_LOCK_MS,
+      signatureDeadlineSeconds: config.signatureDeadlineSeconds ?? DEFAULT_SIG_DEADLINE_SEC2,
+      now: config.now ?? (() => Date.now())
+    };
+  }
+  async handle(request) {
+    if (getAddress8(request.authenticatedAddress) !== getAddress8(request.userAddress)) {
+      throw new PTClaimError(
+        "VALIDATION_FAILED",
+        `userAddress (${request.userAddress}) does not match authenticated session (${request.authenticatedAddress})`
+      );
+    }
+    if (request.amount <= 0n) {
+      throw new PTClaimError("INVALID_AMOUNT", "claim amount must be positive");
+    }
+    if (this.cfg.issuerStateValidator) {
+      try {
+        await this.cfg.issuerStateValidator.preValidateMint(
+          request.pointTokenAddress,
+          request.amount
+        );
+      } catch (err) {
+        if (err instanceof IssuerStateError) throw err;
+        throw new PTClaimError(
+          "VALIDATION_FAILED",
+          `issuer-state pre-validate failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const { batchExecutor: batchExecutorAddress } = getContractAddresses2(
+      request.chainId
+    );
+    const lockId = await this.cfg.ledger.lockForMinting(
+      request.userAddress,
+      request.amount,
+      this.cfg.lockDurationMs,
+      request.pointTokenAddress
+    );
+    const signatureDeadline = BigInt(
+      Math.floor(this.cfg.now() / 1e3) + this.cfg.signatureDeadlineSeconds
+    );
+    const feeAmount = this.cfg.feeService ? await this.cfg.feeService.estimateGasFee() : 0n;
+    const domain = {
+      name: this.cfg.pointTokenDomainName,
+      chainId: request.chainId,
+      verifyingContract: request.pointTokenAddress
+    };
+    let userOp;
+    try {
+      userOp = await this.cfg.relayService.prepareMint({
+        userAddress: request.userAddress,
+        aaNonce: request.aaNonce,
+        batchExecutorAddress,
+        pointTokenAddress: request.pointTokenAddress,
+        amount: request.amount,
+        issuerSignerWallet: this.cfg.issuerSignerWallet,
+        domain,
+        mintRequestNonce: request.mintRequestNonce,
+        deadline: signatureDeadline
+        // No feeAmount/feeRecipient — RelayService auto-resolves.
+      });
+    } catch (err) {
+      throw new PTClaimError(
+        "BUILD_FAILED",
+        `prepareMint failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let fallback;
+    if (feeAmount > 0n) {
+      try {
+        fallback = await this.cfg.relayService.prepareMint({
+          userAddress: request.userAddress,
+          aaNonce: request.aaNonce,
+          batchExecutorAddress,
+          pointTokenAddress: request.pointTokenAddress,
+          amount: request.amount,
+          issuerSignerWallet: this.cfg.issuerSignerWallet,
+          domain,
+          mintRequestNonce: request.mintRequestNonce,
+          deadline: signatureDeadline,
+          feeAmount: 0n
+        });
+      } catch (err) {
+        throw new PTClaimError(
+          "BUILD_FAILED",
+          `prepareMint (fallback) failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const calls = decodeBatchExecuteCalls(userOp.callData);
+    const callsFallback = fallback ? decodeBatchExecuteCalls(fallback.callData) : void 0;
+    return {
+      userOp,
+      fallback,
+      lockId,
+      feeAmount,
+      signatureDeadline,
+      expiresInSeconds: Math.floor(this.cfg.lockDurationMs / 1e3),
+      calls,
+      callsFallback
+    };
+  }
+};
+
+// src/api/handlers/swapHandler.ts
+import {
+  buildSwapWithGasDeduction,
+  decodeBatchExecuteCalls as decodeBatchExecuteCalls2,
+  findBestQuote,
+  getContractAddresses as getContractAddresses3
+} from "@pafi-dev/core";
+var SwapError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SwapError";
+  }
+  code;
+};
+var DEFAULT_SLIPPAGE_BPS = 50;
+var DEFAULT_SWAP_DEADLINE_SEC = 5 * 60;
+var SwapHandler = class {
+  cfg;
+  constructor(config) {
+    this.cfg = {
+      ...config,
+      defaultSlippageBps: config.defaultSlippageBps ?? DEFAULT_SLIPPAGE_BPS,
+      defaultSwapDeadlineSeconds: config.defaultSwapDeadlineSeconds ?? DEFAULT_SWAP_DEADLINE_SEC,
+      now: config.now ?? (() => Date.now())
+    };
+  }
+  async handle(request) {
+    if (request.amountIn <= 0n) {
+      throw new SwapError("INVALID_AMOUNT", "amountIn must be positive");
+    }
+    const slippageBps = request.slippageBps ?? this.cfg.defaultSlippageBps;
+    const { usdt, pafiFeeRecipient, universalRouter } = getContractAddresses3(
+      request.chainId
+    );
+    const poolsResponse = await this.cfg.poolsProvider({
+      chainId: request.chainId,
+      pointTokenAddress: request.pointTokenAddress
+    });
+    if (poolsResponse.pools.length === 0) {
+      throw new SwapError(
+        "QUOTE_UNAVAILABLE",
+        "no liquidity pool found for this point token"
+      );
+    }
+    let fallbackQuote;
+    try {
+      fallbackQuote = await findBestQuote(
+        this.cfg.provider,
+        request.chainId,
+        request.pointTokenAddress,
+        usdt,
+        request.amountIn,
+        poolsResponse.pools
+      );
+    } catch {
+      throw new SwapError(
+        "QUOTE_UNAVAILABLE",
+        "no swap path found for this point token"
+      );
+    }
+    const estimatedUsdtOutFallback = fallbackQuote.bestRoute.amountOut;
+    const minAmountOutFallback = estimatedUsdtOutFallback * BigInt(1e4 - slippageBps) / 10000n;
+    const deadline = request.deadline ?? BigInt(
+      Math.floor(this.cfg.now() / 1e3) + this.cfg.defaultSwapDeadlineSeconds
+    );
+    const feeAmount = this.cfg.feeService ? await this.cfg.feeService.estimateGasFee() : 0n;
+    if (feeAmount > 0n && feeAmount >= request.amountIn) {
+      throw new SwapError(
+        "FEE_EXCEEDS_AMOUNT",
+        `gas fee (${feeAmount}) must be strictly less than swap amount (${request.amountIn})`
+      );
+    }
+    const sponsoredAmountIn = request.amountIn - feeAmount;
+    let estimatedUsdtOutSponsored = estimatedUsdtOutFallback;
+    let sponsoredPath = fallbackQuote.bestRoute.path;
+    if (feeAmount > 0n) {
+      try {
+        const sponsoredQuote = await findBestQuote(
+          this.cfg.provider,
+          request.chainId,
+          request.pointTokenAddress,
+          usdt,
+          sponsoredAmountIn,
+          poolsResponse.pools
+        );
+        estimatedUsdtOutSponsored = sponsoredQuote.bestRoute.amountOut;
+        sponsoredPath = sponsoredQuote.bestRoute.path;
+      } catch {
+        throw new SwapError(
+          "QUOTE_UNAVAILABLE",
+          "no swap path found for sponsored amount (after fee deduction)"
+        );
+      }
+    }
+    const minAmountOutSponsored = estimatedUsdtOutSponsored * BigInt(1e4 - slippageBps) / 10000n;
+    const sponsoredOp = buildSwapWithGasDeduction({
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      pointTokenAddress: request.pointTokenAddress,
+      outputTokenAddress: usdt,
+      universalRouterAddress: universalRouter,
+      amountIn: sponsoredAmountIn,
+      minAmountOut: minAmountOutSponsored,
+      swapPath: sponsoredPath,
+      deadline,
+      gasFeePt: feeAmount,
+      feeRecipient: pafiFeeRecipient
+    });
+    const fallbackOp = feeAmount > 0n ? buildSwapWithGasDeduction({
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      pointTokenAddress: request.pointTokenAddress,
+      outputTokenAddress: usdt,
+      universalRouterAddress: universalRouter,
+      amountIn: request.amountIn,
+      minAmountOut: minAmountOutFallback,
+      swapPath: fallbackQuote.bestRoute.path,
+      deadline,
+      gasFeePt: 0n,
+      feeRecipient: pafiFeeRecipient
+    }) : void 0;
+    return {
+      userOp: sponsoredOp,
+      fallback: fallbackOp,
+      feeAmount,
+      estimatedUsdtOut: estimatedUsdtOutSponsored,
+      minAmountOut: minAmountOutSponsored,
+      estimatedUsdtOutFallback: fallbackOp ? estimatedUsdtOutFallback : void 0,
+      minAmountOutFallback: fallbackOp ? minAmountOutFallback : void 0,
+      deadline,
+      calls: decodeBatchExecuteCalls2(sponsoredOp.callData),
+      callsFallback: fallbackOp ? decodeBatchExecuteCalls2(fallbackOp.callData) : void 0
+    };
+  }
+};
+
+// src/api/handlers/perpDepositHandler.ts
+import {
+  BROKER_HASHES,
+  ORDERLY_RELAY_ABI,
+  ORDERLY_VAULT_ABI,
+  ORDERLY_VAULT_ADDRESSES,
+  TOKEN_HASHES,
+  buildPerpDepositViaRelay,
+  computeAccountId,
+  decodeBatchExecuteCalls as decodeBatchExecuteCalls3,
+  getContractAddresses as getContractAddresses4
+} from "@pafi-dev/core";
+var PerpDepositError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PerpDepositError";
+  }
+  code;
+};
+var DEFAULT_MAX_FEE_PREMIUM_BPS = 5e3;
+var PerpDepositHandler = class {
+  cfg;
+  constructor(config) {
+    this.cfg = {
+      ...config,
+      maxFeePremiumBps: config.maxFeePremiumBps ?? DEFAULT_MAX_FEE_PREMIUM_BPS
+    };
+  }
+  async handle(request) {
+    if (request.amount <= 0n) {
+      throw new PerpDepositError("INVALID_AMOUNT", "amount must be positive");
+    }
+    const brokerHash = BROKER_HASHES[request.brokerId];
+    const tokenHash = TOKEN_HASHES.USDC;
+    const vault = ORDERLY_VAULT_ADDRESSES[request.chainId];
+    if (!vault) {
+      throw new PerpDepositError(
+        "PERP_DEPOSIT_UNAVAILABLE",
+        `no Orderly Vault for chainId ${request.chainId}`
+      );
+    }
+    const { orderlyRelay: relayAddress, pafiFeeRecipient } = getContractAddresses4(request.chainId);
+    const [usdcAddress, brokerAllowed] = await Promise.all([
+      this.cfg.provider.readContract({
+        address: vault,
+        abi: ORDERLY_VAULT_ABI,
+        functionName: "getAllowedToken",
+        args: [tokenHash]
+      }),
+      this.cfg.provider.readContract({
+        address: vault,
+        abi: ORDERLY_VAULT_ABI,
+        functionName: "getAllowedBroker",
+        args: [brokerHash]
+      })
+    ]);
+    if (!brokerAllowed) {
+      throw new PerpDepositError(
+        "BROKER_NOT_WHITELISTED",
+        `broker "${request.brokerId}" is not whitelisted on Orderly Vault`
+      );
+    }
+    const accountId = computeAccountId(request.userAddress, brokerHash);
+    const requestForQuote = {
+      token: usdcAddress,
+      receiver: request.userAddress,
+      brokerHash,
+      totalAmount: request.amount,
+      maxFee: 0n
+    };
+    const [relayTokenFee, ptGasFee] = await Promise.all([
+      this.cfg.provider.readContract({
+        address: relayAddress,
+        abi: ORDERLY_RELAY_ABI,
+        functionName: "quoteTokenFee",
+        args: [requestForQuote]
+      }),
+      this.cfg.feeService ? this.cfg.feeService.estimateGasFee() : Promise.resolve(0n)
+    ]);
+    if (relayTokenFee >= request.amount) {
+      throw new PerpDepositError(
+        "RELAY_FEE_EXCEEDS_AMOUNT",
+        `Relay quoted fee ${relayTokenFee} >= deposit amount ${request.amount}`
+      );
+    }
+    const maxFee = relayTokenFee * BigInt(1e4 + this.cfg.maxFeePremiumBps) / 10000n;
+    const depositReq = {
+      token: usdcAddress,
+      receiver: request.userAddress,
+      brokerHash,
+      totalAmount: request.amount,
+      maxFee
+    };
+    const sponsoredOp = buildPerpDepositViaRelay({
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      relayAddress,
+      request: depositReq,
+      pointTokenAddress: this.cfg.pointTokenAddress,
+      gasFeePt: ptGasFee,
+      gasFeePtRecipient: pafiFeeRecipient
+    });
+    const fallbackOp = ptGasFee > 0n ? buildPerpDepositViaRelay({
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      relayAddress,
+      request: depositReq
+    }) : void 0;
+    return {
+      userOp: sponsoredOp,
+      fallback: fallbackOp,
+      feeAmount: ptGasFee,
+      relayTokenFee,
+      maxFee,
+      netDeposit: request.amount - relayTokenFee,
+      accountId,
+      brokerHash,
+      usdcAddress,
+      relayAddress,
+      calls: decodeBatchExecuteCalls3(sponsoredOp.callData),
+      callsFallback: fallbackOp ? decodeBatchExecuteCalls3(fallbackOp.callData) : void 0
+    };
+  }
+};
+
 // src/pools/subgraphPoolsProvider.ts
 import { isAddress } from "viem";
 import { PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
@@ -2316,8 +2993,8 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-import { getAddress as getAddress8 } from "viem";
-import { getContractAddresses as getContractAddresses2 } from "@pafi-dev/core";
+import { getAddress as getAddress9 } from "viem";
+import { getContractAddresses as getContractAddresses5 } from "@pafi-dev/core";
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -2337,7 +3014,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => getAddress8(a));
+  const tokenAddresses = rawAddresses.map((a) => getAddress9(a));
   const ledger = config.ledger;
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -2387,7 +3064,7 @@ function createIssuerService(config) {
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
   const firstIndexer = indexers.get(tokenAddresses[0]);
-  const chainAddresses = getContractAddresses2(config.chainId);
+  const chainAddresses = getContractAddresses5(config.chainId);
   const resolvedContracts = {
     batchExecutor: chainAddresses.batchExecutor,
     usdt: chainAddresses.usdt,
@@ -2434,163 +3111,13 @@ function createIssuerService(config) {
   };
 }
 
-// src/userop-store/serialize.ts
-import { serializeUserOpToJsonRpc } from "@pafi-dev/core";
-function serializeEntryToJsonRpc(entry, signature, variant = "sponsored") {
-  if (variant === "fallback") {
-    if (!entry.fallback) {
-      throw new Error(
-        "serializeEntryToJsonRpc: variant=fallback requested but the stored entry has no `fallback` branch \u2014 caller should resubmit with variant='sponsored' or re-prepare with a fee configured."
-      );
-    }
-    return serializeUserOpToJsonRpc(
-      {
-        sender: entry.sender,
-        nonce: BigInt(entry.nonce),
-        callData: entry.fallback.callData,
-        callGasLimit: BigInt(entry.fallback.callGasLimit),
-        verificationGasLimit: BigInt(entry.fallback.verificationGasLimit),
-        preVerificationGas: BigInt(entry.fallback.preVerificationGas),
-        maxFeePerGas: BigInt(entry.maxFeePerGas),
-        maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas)
-        // intentionally no paymaster — user pays ETH gas
-      },
-      signature
-    );
-  }
-  return serializeUserOpToJsonRpc(
-    {
-      sender: entry.sender,
-      nonce: BigInt(entry.nonce),
-      callData: entry.callData,
-      callGasLimit: BigInt(entry.callGasLimit),
-      verificationGasLimit: BigInt(entry.verificationGasLimit),
-      preVerificationGas: BigInt(entry.preVerificationGas),
-      maxFeePerGas: BigInt(entry.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas),
-      paymaster: entry.paymaster,
-      paymasterVerificationGasLimit: entry.paymasterVerificationGasLimit != null ? BigInt(entry.paymasterVerificationGasLimit) : void 0,
-      paymasterPostOpGasLimit: entry.paymasterPostOpGasLimit != null ? BigInt(entry.paymasterPostOpGasLimit) : void 0,
-      paymasterData: entry.paymasterData
-    },
-    signature
-  );
-}
-
-// src/userop-store/prepareUserOp.ts
-import {
-  buildUserOpTypedData,
-  computeUserOpHash
-} from "@pafi-dev/core";
-function serializeUserOpTypedData(td) {
-  return {
-    domain: td.domain,
-    types: td.types,
-    primaryType: td.primaryType,
-    message: {
-      sender: td.message.sender,
-      nonce: `0x${td.message.nonce.toString(16)}`,
-      initCode: td.message.initCode,
-      callData: td.message.callData,
-      accountGasLimits: td.message.accountGasLimits,
-      preVerificationGas: `0x${td.message.preVerificationGas.toString(
-        16
-      )}`,
-      gasFees: td.message.gasFees,
-      paymasterAndData: td.message.paymasterAndData
-    }
-  };
-}
-function mergePaymasterFields(userOp, paymasterFields) {
-  if (!paymasterFields) return userOp;
-  const merged = {
-    ...userOp
-  };
-  for (const [k, v] of Object.entries(paymasterFields)) {
-    if (v !== void 0) merged[k] = v;
-  }
-  return merged;
-}
-async function prepareMobileUserOp(params) {
-  const userOp = mergePaymasterFields(
-    params.partialUserOp,
-    params.paymasterFields
-  );
-  const userOpHash = computeUserOpHash(userOp, params.chainId);
-  const typedData = serializeUserOpTypedData(
-    buildUserOpTypedData(userOp, params.chainId)
-  );
-  let fallback;
-  let fallbackEntry;
-  if (params.partialUserOpFallback) {
-    const fallbackUserOp = {
-      ...params.partialUserOpFallback,
-      maxFeePerGas: userOp.maxFeePerGas,
-      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
-    };
-    const fallbackHash = computeUserOpHash(fallbackUserOp, params.chainId);
-    const fallbackTypedData = serializeUserOpTypedData(
-      buildUserOpTypedData(fallbackUserOp, params.chainId)
-    );
-    fallback = {
-      userOp: fallbackUserOp,
-      userOpHash: fallbackHash,
-      typedData: fallbackTypedData
-    };
-    fallbackEntry = {
-      callData: fallbackUserOp.callData,
-      callGasLimit: fallbackUserOp.callGasLimit.toString(),
-      verificationGasLimit: fallbackUserOp.verificationGasLimit.toString(),
-      preVerificationGas: fallbackUserOp.preVerificationGas.toString(),
-      userOpHash: fallbackHash
-    };
-  }
-  const entry = {
-    sender: userOp.sender,
-    nonce: userOp.nonce.toString(),
-    callData: userOp.callData,
-    callGasLimit: userOp.callGasLimit.toString(),
-    verificationGasLimit: userOp.verificationGasLimit.toString(),
-    preVerificationGas: userOp.preVerificationGas.toString(),
-    maxFeePerGas: userOp.maxFeePerGas.toString(),
-    maxPriorityFeePerGas: userOp.maxPriorityFeePerGas.toString(),
-    paymaster: userOp.paymaster,
-    paymasterVerificationGasLimit: userOp.paymasterVerificationGasLimit?.toString(),
-    paymasterPostOpGasLimit: userOp.paymasterPostOpGasLimit?.toString(),
-    paymasterData: userOp.paymasterData,
-    chainId: params.chainId,
-    userOpHash,
-    fallback: fallbackEntry
-  };
-  await params.store.save(params.lockId, entry, params.ttlSeconds);
-  return {
-    sponsored: { userOp, userOpHash, typedData },
-    fallback,
-    entry
-  };
-}
-
 // src/issuer-state/validator.ts
-import { getAddress as getAddress9 } from "viem";
+import { getAddress as getAddress10 } from "viem";
 import {
   POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI3,
   issuerRegistryGetIssuerFlatAbi,
-  getContractAddresses as getContractAddresses3
+  getContractAddresses as getContractAddresses6
 } from "@pafi-dev/core";
-
-// src/issuer-state/types.ts
-var IssuerStateError = class extends Error {
-  constructor(code, message, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "IssuerStateError";
-  }
-  code;
-  details;
-};
-
-// src/issuer-state/validator.ts
 var ISSUER_RECORD_TTL_MS = 3e4;
 var IssuerStateValidator = class _IssuerStateValidator {
   constructor(provider, registryAddress) {
@@ -2607,7 +3134,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * `CONTRACT_ADDRESSES` map for the given chain.
    */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = getContractAddresses3(chainId);
+    const { issuerRegistry } = getContractAddresses6(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
@@ -2616,7 +3143,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    */
   invalidate(pointToken) {
     if (pointToken) {
-      const key = getAddress9(pointToken);
+      const key = getAddress10(pointToken);
       this.pointTokenIssuerCache.delete(key);
       this.stateCache.delete(key);
       this.inflight.delete(key);
@@ -2631,7 +3158,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * The issuer field is set at `initialize()` and never changes.
    */
   async getIssuerAddressForPointToken(pointToken) {
-    const key = getAddress9(pointToken);
+    const key = getAddress10(pointToken);
     const cached = this.pointTokenIssuerCache.get(key);
     if (cached) return cached;
     const issuer = await this.provider.readContract({
@@ -2639,15 +3166,15 @@ var IssuerStateValidator = class _IssuerStateValidator {
       abi: POINT_TOKEN_V2_ABI3,
       functionName: "issuer"
     });
-    this.pointTokenIssuerCache.set(key, getAddress9(issuer));
-    return getAddress9(issuer);
+    this.pointTokenIssuerCache.set(key, getAddress10(issuer));
+    return getAddress10(issuer);
   }
   /**
    * Read registry record + totalSupply, with 30s cache and in-flight
    * deduplication. Does NOT throw on inactive/missing — returns raw state.
    */
   async getIssuerState(pointToken) {
-    const tokenAddr = getAddress9(pointToken);
+    const tokenAddr = getAddress10(pointToken);
     const now = Date.now();
     const cached = this.stateCache.get(tokenAddr);
     if (cached && cached.expiresAt > now) return cached.value;
@@ -2750,6 +3277,8 @@ export {
   AuthError,
   AuthService,
   BalanceAggregator,
+  BundlerNotConfiguredError,
+  BundlerRejectedError,
   BurnIndexer,
   DefaultPolicyEngine,
   FeeManager,
@@ -2762,13 +3291,20 @@ export {
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
   PAFI_SUBGRAPH_URL,
+  PTClaimError,
+  PTClaimHandler,
   PTRedeemError,
   PTRedeemHandler,
   PafiBackendClient,
   PafiBackendError,
+  PendingUserOpNotFoundError,
+  PerpDepositError,
+  PerpDepositHandler,
   PointIndexer,
   RelayError,
   RelayService,
+  SwapError,
+  SwapHandler,
   TopUpRedemptionError,
   TopUpRedemptionHandler,
   authenticateRequest,
@@ -2777,9 +3313,13 @@ export {
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,
   handleClaimStatus,
+  handleMobilePrepare,
+  handleMobileSubmit,
   handleRedeemStatus,
   mergePaymasterFields,
   prepareMobileUserOp,
+  relayUserOp,
+  requestPaymaster,
   serializeEntryToJsonRpc,
   serializeUserOpTypedData
 };