@pafi-dev/issuer 0.5.32 → 0.5.34

package/dist/index.cjs

@@ -23,6 +23,8 @@ __export(index_exports, {
   AuthError: () => AuthError,
   AuthService: () => AuthService,
   BalanceAggregator: () => BalanceAggregator,
+  BundlerNotConfiguredError: () => BundlerNotConfiguredError,
+  BundlerRejectedError: () => BundlerRejectedError,
   BurnIndexer: () => BurnIndexer,
   DefaultPolicyEngine: () => DefaultPolicyEngine,
   FeeManager: () => FeeManager,
@@ -30,6 +32,7 @@ __export(index_exports, {
   IssuerApiHandlers: () => IssuerApiHandlers,
   IssuerStateError: () => IssuerStateError,
   IssuerStateValidator: () => IssuerStateValidator,
+  LockNotFoundError: () => LockNotFoundError,
   MemorySessionStore: () => MemorySessionStore,
   NonceManager: () => NonceManager,
   PAFI_ISSUER_SDK_VERSION: () => PAFI_ISSUER_SDK_VERSION,
@@ -48,7 +51,14 @@ __export(index_exports, {
   createNativePtQuoter: () => createNativePtQuoter,
   createSubgraphNativeUsdtQuoter: () => createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider: () => createSubgraphPoolsProvider,
-  serializeEntryToJsonRpc: () => serializeEntryToJsonRpc
+  handleClaimStatus: () => handleClaimStatus,
+  handleRedeemStatus: () => handleRedeemStatus,
+  mergePaymasterFields: () => mergePaymasterFields,
+  prepareMobileUserOp: () => prepareMobileUserOp,
+  relayUserOp: () => relayUserOp,
+  requestPaymaster: () => requestPaymaster,
+  serializeEntryToJsonRpc: () => serializeEntryToJsonRpc,
+  serializeUserOpTypedData: () => serializeUserOpTypedData
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1637,6 +1647,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
 var import_viem9 = require("viem");
 var import_core6 = require("@pafi-dev/core");
@@ -2254,6 +2364,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
 var import_viem11 = require("viem");
 var import_core8 = require("@pafi-dev/core");
@@ -2416,9 +2596,99 @@ function serializeEntryToJsonRpc(entry, signature, variant = "sponsored") {
   );
 }
 
+// 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_core10 = require("@pafi-dev/core");
+var import_core11 = require("@pafi-dev/core");
 
 // src/issuer-state/types.ts
 var IssuerStateError = class extends Error {
@@ -2449,7 +2719,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * `CONTRACT_ADDRESSES` map for the given chain.
    */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = (0, import_core10.getContractAddresses)(chainId);
+    const { issuerRegistry } = (0, import_core11.getContractAddresses)(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
@@ -2478,7 +2748,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
     if (cached) return cached;
     const issuer = await this.provider.readContract({
       address: key,
-      abi: import_core10.POINT_TOKEN_V2_ABI,
+      abi: import_core11.POINT_TOKEN_V2_ABI,
       functionName: "issuer"
     });
     this.pointTokenIssuerCache.set(key, (0, import_viem12.getAddress)(issuer));
@@ -2559,13 +2829,13 @@ var IssuerStateValidator = class _IssuerStateValidator {
     const [issuerTuple, totalSupply] = await Promise.all([
       this.provider.readContract({
         address: this.registryAddress,
-        abi: import_core10.issuerRegistryGetIssuerFlatAbi,
+        abi: import_core11.issuerRegistryGetIssuerFlatAbi,
         functionName: "getIssuer",
         args: [issuerAddr]
       }),
       this.provider.readContract({
         address: tokenAddr,
-        abi: import_core10.POINT_TOKEN_V2_ABI,
+        abi: import_core11.POINT_TOKEN_V2_ABI,
         functionName: "totalSupply"
       })
     ]);
@@ -2593,6 +2863,8 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   AuthError,
   AuthService,
   BalanceAggregator,
+  BundlerNotConfiguredError,
+  BundlerRejectedError,
   BurnIndexer,
   DefaultPolicyEngine,
   FeeManager,
@@ -2600,6 +2872,7 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   IssuerApiHandlers,
   IssuerStateError,
   IssuerStateValidator,
+  LockNotFoundError,
   MemorySessionStore,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
@@ -2618,6 +2891,13 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   createNativePtQuoter,
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,
-  serializeEntryToJsonRpc
+  handleClaimStatus,
+  handleRedeemStatus,
+  mergePaymasterFields,
+  prepareMobileUserOp,
+  relayUserOp,
+  requestPaymaster,
+  serializeEntryToJsonRpc,
+  serializeUserOpTypedData
 });
 //# sourceMappingURL=index.cjs.map