@pafi-dev/issuer 0.5.32 → 0.5.33

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";
@@ -2377,6 +2477,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 {
@@ -2564,6 +2757,7 @@ export {
   IssuerApiHandlers,
   IssuerStateError,
   IssuerStateValidator,
+  LockNotFoundError,
   MemorySessionStore,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
@@ -2582,6 +2776,11 @@ export {
   createNativePtQuoter,
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,
-  serializeEntryToJsonRpc
+  handleClaimStatus,
+  handleRedeemStatus,
+  mergePaymasterFields,
+  prepareMobileUserOp,
+  serializeEntryToJsonRpc,
+  serializeUserOpTypedData
 };
 //# sourceMappingURL=index.js.map