@pafi-dev/issuer 0.5.34 → 0.5.36

package/dist/index.cjs

@@ -36,14 +36,21 @@ __export(index_exports, {
   MemorySessionStore: () => MemorySessionStore,
   NonceManager: () => NonceManager,
   PAFI_ISSUER_SDK_VERSION: () => PAFI_ISSUER_SDK_VERSION,
-  PAFI_SUBGRAPH_URL: () => import_core6.PAFI_SUBGRAPH_URL,
+  PAFI_SUBGRAPH_URL: () => import_core12.PAFI_SUBGRAPH_URL,
+  PTClaimError: () => PTClaimError,
+  PTClaimHandler: () => PTClaimHandler,
   PTRedeemError: () => PTRedeemError,
   PTRedeemHandler: () => PTRedeemHandler,
   PafiBackendClient: () => PafiBackendClient,
   PafiBackendError: () => PafiBackendError,
+  PendingUserOpNotFoundError: () => PendingUserOpNotFoundError,
+  PerpDepositError: () => PerpDepositError,
+  PerpDepositHandler: () => PerpDepositHandler,
   PointIndexer: () => PointIndexer,
   RelayError: () => RelayError,
   RelayService: () => RelayService,
+  SwapError: () => SwapError,
+  SwapHandler: () => SwapHandler,
   TopUpRedemptionError: () => TopUpRedemptionError,
   TopUpRedemptionHandler: () => TopUpRedemptionHandler,
   authenticateRequest: () => authenticateRequest,
@@ -52,6 +59,8 @@ __export(index_exports, {
   createSubgraphNativeUsdtQuoter: () => createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider: () => createSubgraphPoolsProvider,
   handleClaimStatus: () => handleClaimStatus,
+  handleMobilePrepare: () => handleMobilePrepare,
+  handleMobileSubmit: () => handleMobileSubmit,
   handleRedeemStatus: () => handleRedeemStatus,
   mergePaymasterFields: () => mergePaymasterFields,
   prepareMobileUserOp: () => prepareMobileUserOp,
@@ -1747,9 +1756,662 @@ async function handleRedeemStatus(params) {
   };
 }
 
+// src/api/mobileHandlers.ts
+var import_core8 = require("@pafi-dev/core");
+
+// src/userop-store/serialize.ts
+var import_core6 = require("@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 (0, import_core6.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 (0, import_core6.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
+var import_core7 = require("@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 = (0, import_core7.computeUserOpHash)(userOp, params.chainId);
+  const typedData = serializeUserOpTypedData(
+    (0, import_core7.buildUserOpTypedData)(userOp, params.chainId)
+  );
+  let fallback;
+  let fallbackEntry;
+  if (params.partialUserOpFallback) {
+    const fallbackUserOp = {
+      ...params.partialUserOpFallback,
+      maxFeePerGas: userOp.maxFeePerGas,
+      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
+    };
+    const fallbackHash = (0, import_core7.computeUserOpHash)(fallbackUserOp, params.chainId);
+    const fallbackTypedData = serializeUserOpTypedData(
+      (0, import_core7.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 = (0, import_core8.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 ?? import_core8.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
+var import_viem9 = require("viem");
+var import_core9 = require("@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 ((0, import_viem9.getAddress)(request.authenticatedAddress) !== (0, import_viem9.getAddress)(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 } = (0, import_core9.getContractAddresses)(
+      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 = (0, import_core9.decodeBatchExecuteCalls)(userOp.callData);
+    const callsFallback = fallback ? (0, import_core9.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
+var import_core10 = require("@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 } = (0, import_core10.getContractAddresses)(
+      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 (0, import_core10.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 (0, import_core10.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 = (0, import_core10.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 ? (0, import_core10.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: (0, import_core10.decodeBatchExecuteCalls)(sponsoredOp.callData),
+      callsFallback: fallbackOp ? (0, import_core10.decodeBatchExecuteCalls)(fallbackOp.callData) : void 0
+    };
+  }
+};
+
+// src/api/handlers/perpDepositHandler.ts
+var import_core11 = require("@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 = import_core11.BROKER_HASHES[request.brokerId];
+    const tokenHash = import_core11.TOKEN_HASHES.USDC;
+    const vault = import_core11.ORDERLY_VAULT_ADDRESSES[request.chainId];
+    if (!vault) {
+      throw new PerpDepositError(
+        "PERP_DEPOSIT_UNAVAILABLE",
+        `no Orderly Vault for chainId ${request.chainId}`
+      );
+    }
+    const { orderlyRelay: relayAddress, pafiFeeRecipient } = (0, import_core11.getContractAddresses)(request.chainId);
+    const [usdcAddress, brokerAllowed] = await Promise.all([
+      this.cfg.provider.readContract({
+        address: vault,
+        abi: import_core11.ORDERLY_VAULT_ABI,
+        functionName: "getAllowedToken",
+        args: [tokenHash]
+      }),
+      this.cfg.provider.readContract({
+        address: vault,
+        abi: import_core11.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 = (0, import_core11.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: import_core11.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 = (0, import_core11.buildPerpDepositViaRelay)({
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      relayAddress,
+      request: depositReq,
+      pointTokenAddress: this.cfg.pointTokenAddress,
+      gasFeePt: ptGasFee,
+      gasFeePtRecipient: pafiFeeRecipient
+    });
+    const fallbackOp = ptGasFee > 0n ? (0, import_core11.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: (0, import_core11.decodeBatchExecuteCalls)(sponsoredOp.callData),
+      callsFallback: fallbackOp ? (0, import_core11.decodeBatchExecuteCalls)(fallbackOp.callData) : void 0
+    };
+  }
+};
+
 // src/pools/subgraphPoolsProvider.ts
-var import_viem9 = require("viem");
-var import_core6 = require("@pafi-dev/core");
+var import_viem10 = require("viem");
+var import_core12 = require("@pafi-dev/core");
 var DEFAULT_CACHE_TTL_MS = 3e4;
 var POOL_QUERY = `
   query GetPoolForPointToken($id: ID!) {
@@ -1767,7 +2429,7 @@ var POOL_QUERY = `
   }
 `;
 function createSubgraphPoolsProvider(config = {}) {
-  const subgraphUrl = config.subgraphUrl ?? import_core6.PAFI_SUBGRAPH_URL;
+  const subgraphUrl = config.subgraphUrl ?? import_core12.PAFI_SUBGRAPH_URL;
   try {
     const parsed = new URL(subgraphUrl);
     if (process.env.NODE_ENV === "production" && parsed.protocol !== "https:") {
@@ -1849,7 +2511,7 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
     return [];
   }
   const { pool } = token;
-  if (!(0, import_viem9.isAddress)(pool.hooks)) {
+  if (!(0, import_viem10.isAddress)(pool.hooks)) {
     console.error(
       "[PAFI] SubgraphPoolsProvider: invalid hooks address in response:",
       pool.hooks,
@@ -1857,7 +2519,7 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
     );
     return [];
   }
-  if (!(0, import_viem9.isAddress)(pool.token0.id) || !(0, import_viem9.isAddress)(pool.token1.id)) {
+  if (!(0, import_viem10.isAddress)(pool.token0.id) || !(0, import_viem10.isAddress)(pool.token1.id)) {
     console.error(
       "[PAFI] SubgraphPoolsProvider: invalid token address in response \u2014 skipping pool"
     );
@@ -1899,7 +2561,7 @@ var PRICE_QUERY = `
   }
 `;
 function createSubgraphNativeUsdtQuoter(config = {}) {
-  const subgraphUrl = config.subgraphUrl ?? import_core6.PAFI_SUBGRAPH_URL;
+  const subgraphUrl = config.subgraphUrl ?? import_core12.PAFI_SUBGRAPH_URL;
   try {
     const parsed = new URL(subgraphUrl);
     if (process.env.NODE_ENV === "production" && parsed.protocol !== "https:") {
@@ -2007,8 +2669,8 @@ function toUsdtPerNative(priceFloat, usdtDecimals) {
 }
 
 // src/pools/nativePtQuoter.ts
-var import_viem10 = require("viem");
-var CHAINLINK_ABI = (0, import_viem10.parseAbi)([
+var import_viem11 = require("viem");
+var CHAINLINK_ABI = (0, import_viem11.parseAbi)([
   "function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)"
 ]);
 var CHAINLINK_MAX_AGE_S = 3600n;
@@ -2029,7 +2691,7 @@ function createNativePtQuoter(config) {
     provider,
     pointTokenAddress,
     chainlinkFeedAddress = "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
-    subgraphUrl = import_core6.PAFI_SUBGRAPH_URL,
+    subgraphUrl = import_core12.PAFI_SUBGRAPH_URL,
     cacheTtlMs = 3e4,
     fallbackEthPriceUsd = 3e3,
     fallbackPtPriceUsdt = 0.1,
@@ -2111,7 +2773,7 @@ function parseBigDecimalTo18(s) {
 }
 
 // src/balance/balanceAggregator.ts
-var import_core7 = require("@pafi-dev/core");
+var import_core13 = require("@pafi-dev/core");
 var BalanceAggregator = class {
   provider;
   ledger;
@@ -2132,7 +2794,7 @@ var BalanceAggregator = class {
   async getCombinedBalance(user, pointToken) {
     const [offChain, onChain] = await Promise.all([
       this.ledger.getBalance(user, pointToken),
-      (0, import_core7.getPointTokenBalance)(this.provider, pointToken, user)
+      (0, import_core13.getPointTokenBalance)(this.provider, pointToken, user)
     ]);
     return {
       offChain,
@@ -2364,79 +3026,9 @@ var PafiBackendClient = class {
   }
 };
 
-// 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/config.ts
-var import_viem11 = require("viem");
-var import_core8 = require("@pafi-dev/core");
+var import_viem12 = require("viem");
+var import_core14 = require("@pafi-dev/core");
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -2456,7 +3048,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => (0, import_viem11.getAddress)(a));
+  const tokenAddresses = rawAddresses.map((a) => (0, import_viem12.getAddress)(a));
   const ledger = config.ledger;
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -2506,7 +3098,7 @@ function createIssuerService(config) {
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
   const firstIndexer = indexers.get(tokenAddresses[0]);
-  const chainAddresses = (0, import_core8.getContractAddresses)(config.chainId);
+  const chainAddresses = (0, import_core14.getContractAddresses)(config.chainId);
   const resolvedContracts = {
     batchExecutor: chainAddresses.batchExecutor,
     usdt: chainAddresses.usdt,
@@ -2553,156 +3145,9 @@ function createIssuerService(config) {
   };
 }
 
-// src/userop-store/serialize.ts
-var import_core9 = require("@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 (0, import_core9.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 (0, import_core9.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
-var import_core10 = require("@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 = (0, import_core10.computeUserOpHash)(userOp, params.chainId);
-  const typedData = serializeUserOpTypedData(
-    (0, import_core10.buildUserOpTypedData)(userOp, params.chainId)
-  );
-  let fallback;
-  let fallbackEntry;
-  if (params.partialUserOpFallback) {
-    const fallbackUserOp = {
-      ...params.partialUserOpFallback,
-      maxFeePerGas: userOp.maxFeePerGas,
-      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
-    };
-    const fallbackHash = (0, import_core10.computeUserOpHash)(fallbackUserOp, params.chainId);
-    const fallbackTypedData = serializeUserOpTypedData(
-      (0, import_core10.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
-var import_viem12 = require("viem");
-var import_core11 = require("@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 import_viem13 = require("viem");
+var import_core15 = require("@pafi-dev/core");
 var ISSUER_RECORD_TTL_MS = 3e4;
 var IssuerStateValidator = class _IssuerStateValidator {
   constructor(provider, registryAddress) {
@@ -2719,7 +3164,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * `CONTRACT_ADDRESSES` map for the given chain.
    */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = (0, import_core11.getContractAddresses)(chainId);
+    const { issuerRegistry } = (0, import_core15.getContractAddresses)(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
@@ -2728,7 +3173,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    */
   invalidate(pointToken) {
     if (pointToken) {
-      const key = (0, import_viem12.getAddress)(pointToken);
+      const key = (0, import_viem13.getAddress)(pointToken);
       this.pointTokenIssuerCache.delete(key);
       this.stateCache.delete(key);
       this.inflight.delete(key);
@@ -2743,23 +3188,23 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * The issuer field is set at `initialize()` and never changes.
    */
   async getIssuerAddressForPointToken(pointToken) {
-    const key = (0, import_viem12.getAddress)(pointToken);
+    const key = (0, import_viem13.getAddress)(pointToken);
     const cached = this.pointTokenIssuerCache.get(key);
     if (cached) return cached;
     const issuer = await this.provider.readContract({
       address: key,
-      abi: import_core11.POINT_TOKEN_V2_ABI,
+      abi: import_core15.POINT_TOKEN_V2_ABI,
       functionName: "issuer"
     });
-    this.pointTokenIssuerCache.set(key, (0, import_viem12.getAddress)(issuer));
-    return (0, import_viem12.getAddress)(issuer);
+    this.pointTokenIssuerCache.set(key, (0, import_viem13.getAddress)(issuer));
+    return (0, import_viem13.getAddress)(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 = (0, import_viem12.getAddress)(pointToken);
+    const tokenAddr = (0, import_viem13.getAddress)(pointToken);
     const now = Date.now();
     const cached = this.stateCache.get(tokenAddr);
     if (cached && cached.expiresAt > now) return cached.value;
@@ -2829,13 +3274,13 @@ var IssuerStateValidator = class _IssuerStateValidator {
     const [issuerTuple, totalSupply] = await Promise.all([
       this.provider.readContract({
         address: this.registryAddress,
-        abi: import_core11.issuerRegistryGetIssuerFlatAbi,
+        abi: import_core15.issuerRegistryGetIssuerFlatAbi,
         functionName: "getIssuer",
         args: [issuerAddr]
       }),
       this.provider.readContract({
         address: tokenAddr,
-        abi: import_core11.POINT_TOKEN_V2_ABI,
+        abi: import_core15.POINT_TOKEN_V2_ABI,
         functionName: "totalSupply"
       })
     ]);
@@ -2877,13 +3322,20 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   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,
@@ -2892,6 +3344,8 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,
   handleClaimStatus,
+  handleMobilePrepare,
+  handleMobileSubmit,
   handleRedeemStatus,
   mergePaymasterFields,
   prepareMobileUserOp,