@pafi-dev/issuer 0.5.32 → 0.5.34

package/dist/index.js

@@ -1598,6 +1598,106 @@ var TopUpRedemptionHandler = class {
   }
 };
 
+// src/api/statusHandlers.ts
+var LockNotFoundError = class extends Error {
+  code = "LOCK_NOT_FOUND";
+  constructor() {
+    super("Lock not found or does not belong to authenticated user");
+    this.name = "LockNotFoundError";
+  }
+};
+async function handleClaimStatus(params) {
+  if (!params.ledger.getMintLock) {
+    throw new Error(
+      "handleClaimStatus: ledger does not implement `getMintLock` \u2014 implement the optional method on `IPointLedger` or write a custom status handler."
+    );
+  }
+  const lock = await params.ledger.getMintLock(
+    params.lockId,
+    params.userAddress
+  );
+  if (!lock || lock.userAddress.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new LockNotFoundError();
+  }
+  let status = lock.status;
+  let txHash = lock.txHash ?? null;
+  if (status === "PENDING" && lock.userOpHash && params.pafiBackendClient) {
+    try {
+      const receipt = await params.pafiBackendClient.getUserOpReceipt(
+        lock.userOpHash
+      );
+      if (receipt) {
+        status = receipt.success ? "MINTED" : "FAILED";
+        txHash = receipt.txHash;
+        await params.ledger.updateMintStatus(lock.lockId, status, receipt.txHash).catch((err) => {
+          params.onWarning?.(
+            `handleClaimStatus: ledger updateMintStatus failed for lock ${lock.lockId}: ${err}`
+          );
+        });
+      }
+    } catch (err) {
+      params.onWarning?.(
+        `handleClaimStatus: bundler-receipt fallback failed for lock ${lock.lockId}: ${err}`
+      );
+    }
+  }
+  return {
+    lockId: lock.lockId,
+    status,
+    txHash,
+    amount: lock.amount.toString(),
+    createdAt: new Date(lock.createdAt).toISOString(),
+    expiresAt: new Date(lock.expiresAt).toISOString()
+  };
+}
+async function handleRedeemStatus(params) {
+  if (!params.ledger.getPendingCredit) {
+    throw new Error(
+      "handleRedeemStatus: ledger does not implement `getPendingCredit` \u2014 implement the optional method on `IPointLedger` or write a custom status handler."
+    );
+  }
+  const credit = await params.ledger.getPendingCredit(
+    params.lockId,
+    params.userAddress
+  );
+  if (!credit || credit.userAddress.toLowerCase() !== params.userAddress.toLowerCase()) {
+    throw new LockNotFoundError();
+  }
+  let status = credit.status;
+  let txHash = credit.txHash ?? null;
+  if (status === "PENDING" && credit.userOpHash && params.pafiBackendClient) {
+    try {
+      const receipt = await params.pafiBackendClient.getUserOpReceipt(
+        credit.userOpHash
+      );
+      if (receipt && receipt.success) {
+        status = "RESOLVED";
+        txHash = receipt.txHash;
+        if (params.ledger.resolveCreditByBurnTx) {
+          await params.ledger.resolveCreditByBurnTx(credit.lockId, receipt.txHash).catch((err) => {
+            params.onWarning?.(
+              `handleRedeemStatus: resolveCreditByBurnTx failed for lock ${credit.lockId}: ${err}`
+            );
+          });
+        }
+      }
+    } catch (err) {
+      params.onWarning?.(
+        `handleRedeemStatus: bundler-receipt fallback failed for lock ${credit.lockId}: ${err}`
+      );
+    }
+  }
+  return {
+    lockId: credit.lockId,
+    status,
+    txHash,
+    amount: credit.amount.toString(),
+    createdAt: new Date(credit.createdAt).toISOString(),
+    expiresAt: new Date(credit.expiresAt).toISOString(),
+    resolvedAt: credit.resolvedAt ? new Date(credit.resolvedAt).toISOString() : null
+  };
+}
+
 // src/pools/subgraphPoolsProvider.ts
 import { isAddress } from "viem";
 import { PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
@@ -2215,6 +2315,76 @@ 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
 import { getAddress as getAddress8 } from "viem";
 import { getContractAddresses as getContractAddresses2 } from "@pafi-dev/core";
@@ -2377,6 +2547,99 @@ function serializeEntryToJsonRpc(entry, signature, variant = "sponsored") {
   );
 }
 
+// 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 {
@@ -2557,6 +2820,8 @@ export {
   AuthError,
   AuthService,
   BalanceAggregator,
+  BundlerNotConfiguredError,
+  BundlerRejectedError,
   BurnIndexer,
   DefaultPolicyEngine,
   FeeManager,
@@ -2564,6 +2829,7 @@ export {
   IssuerApiHandlers,
   IssuerStateError,
   IssuerStateValidator,
+  LockNotFoundError,
   MemorySessionStore,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
@@ -2582,6 +2848,13 @@ export {
   createNativePtQuoter,
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,
-  serializeEntryToJsonRpc
+  handleClaimStatus,
+  handleRedeemStatus,
+  mergePaymasterFields,
+  prepareMobileUserOp,
+  relayUserOp,
+  requestPaymaster,
+  serializeEntryToJsonRpc,
+  serializeUserOpTypedData
 };
 //# sourceMappingURL=index.js.map