@pafi-dev/issuer 0.24.1 → 0.25.0

package/dist/index.cjs

@@ -2167,14 +2167,12 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
         { requested: pointToken }
       );
     }
-    const [mintRequestNonce, offChainBalance, onChainBalance, minter] = await Promise.all([
-      (0, import_core6.getMintRequestNonce)(this.provider, pointToken, normalizedAuthed),
+    const [offChainBalance, onChainBalance, minter] = await Promise.all([
       this.ledger.getBalance(normalizedAuthed, pointToken),
       (0, import_core6.getPointTokenBalance)(this.provider, pointToken, normalizedAuthed),
       (0, import_core6.isMinter)(this.provider, pointToken, normalizedAuthed)
     ]);
     return {
-      mintRequestNonce,
       offChainBalance,
       onChainBalance,
       totalBalance: offChainBalance + onChainBalance,
@@ -2311,7 +2309,8 @@ var PointTokenDomainResolver = class {
 var import_viem8 = require("viem");
 var import_core7 = require("@pafi-dev/core");
 var DEFAULT_REDEEM_LOCK_MS = 15 * 60 * 1e3;
-var DEFAULT_SIG_DEADLINE_SEC = 15 * 60;
+var M11_SAFETY_MARGIN_MS = 30 * 1e3;
+var DEFAULT_SIG_DEADLINE_SEC = (DEFAULT_REDEEM_LOCK_MS - M11_SAFETY_MARGIN_MS) / 1e3;
 var PTRedeemError = class extends import_core.PafiSdkError {
   httpStatus = "unprocessable";
   code;
@@ -2378,6 +2377,13 @@ var PTRedeemHandler = class {
     this.redeemLockDurationMs = config.redeemLockDurationMs ?? DEFAULT_REDEEM_LOCK_MS;
     this.signatureDeadlineSeconds = config.signatureDeadlineSeconds ?? DEFAULT_SIG_DEADLINE_SEC;
     this.now = config.now ?? (() => Date.now());
+    const maxAllowedSignatureMs = this.redeemLockDurationMs - M11_SAFETY_MARGIN_MS;
+    if (this.signatureDeadlineSeconds * 1e3 > maxAllowedSignatureMs) {
+      throw new PTRedeemError(
+        "INVALID_AMOUNT",
+        `PTRedeemHandler config: signatureDeadlineSeconds (${this.signatureDeadlineSeconds}s) must be at most redeemLockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (redeemLockDurationMs=${this.redeemLockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS / 1e3}s). See audit M-11.`
+      );
+    }
     if (config.redemptionService) {
       this.redemptionService = config.redemptionService;
     }
@@ -2443,8 +2449,14 @@ var PTRedeemHandler = class {
     }
   }
   async _handleAfterNonceLock(request, burnNonce, pointTokenAddress) {
+    const referenceMs = this.now();
+    const projectedLockExpiresAtMs = referenceMs + this.redeemLockDurationMs;
+    const requestedDeadlineSec = Math.floor(referenceMs / 1e3) + this.signatureDeadlineSeconds;
+    const lockBoundedDeadlineSec = Math.floor(
+      (projectedLockExpiresAtMs - M11_SAFETY_MARGIN_MS) / 1e3
+    );
     const previewDeadline = BigInt(
-      Math.floor(this.now() / 1e3) + this.signatureDeadlineSeconds
+      Math.min(requestedDeadlineSec, lockBoundedDeadlineSec)
     );
     let fee;
     if (request.feeAmount !== void 0) {
@@ -2452,7 +2464,7 @@ var PTRedeemHandler = class {
     } else if (this.feeService) {
       const previewUserOp = this.relayService.previewBurnUserOp({
         userAddress: request.userAddress,
-        aaNonce: burnNonce,
+        aaNonce: request.aaNonce,
         pointTokenAddress,
         amount: request.amount,
         deadline: previewDeadline
@@ -3104,14 +3116,30 @@ function isNoWrapper2(address) {
   return lower === "0x0000000000000000000000000000000000000000" || lower === "0x000000000000000000000000000000000000dead";
 }
 var DEFAULT_LOCK_MS = 15 * 60 * 1e3;
-var DEFAULT_SIG_DEADLINE_SEC2 = 15 * 60;
+var M11_SAFETY_MARGIN_MS2 = 30 * 1e3;
+var DEFAULT_SIG_DEADLINE_SEC2 = (DEFAULT_LOCK_MS - M11_SAFETY_MARGIN_MS2) / 1e3;
 var PTClaimHandler = class {
   cfg;
+  inFlightNonces = /* @__PURE__ */ new Map();
   constructor(config) {
+    const lockDurationMs = config.lockDurationMs ?? DEFAULT_LOCK_MS;
+    const signatureDeadlineSeconds = config.signatureDeadlineSeconds ?? DEFAULT_SIG_DEADLINE_SEC2;
+    const maxAllowedSignatureMs = lockDurationMs - M11_SAFETY_MARGIN_MS2;
+    if (signatureDeadlineSeconds * 1e3 > maxAllowedSignatureMs) {
+      throw new PTClaimError(
+        "VALIDATION_FAILED",
+        `PTClaimHandler config: signatureDeadlineSeconds (${signatureDeadlineSeconds}s) must be at most lockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (lockDurationMs=${lockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS2 / 1e3}s). See audit M-11.`,
+        {
+          lockDurationMs,
+          signatureDeadlineSeconds,
+          maxAllowedSignatureSec: maxAllowedSignatureMs / 1e3
+        }
+      );
+    }
     this.cfg = {
       ...config,
-      lockDurationMs: config.lockDurationMs ?? DEFAULT_LOCK_MS,
-      signatureDeadlineSeconds: config.signatureDeadlineSeconds ?? DEFAULT_SIG_DEADLINE_SEC2,
+      lockDurationMs,
+      signatureDeadlineSeconds,
       now: config.now ?? (() => Date.now())
     };
   }
@@ -3141,77 +3169,82 @@ var PTClaimHandler = class {
     }
     const chainAddresses = (0, import_core11.getContractAddresses)(request.chainId);
     const { batchExecutor: batchExecutorAddress } = chainAddresses;
+    let mintRequestNonce;
+    try {
+      mintRequestNonce = await this.cfg.provider.readContract({
+        address: request.pointTokenAddress,
+        abi: import_core11.POINT_TOKEN_ABI,
+        functionName: "mintRequestNonces",
+        args: [request.userAddress]
+      });
+    } catch (err) {
+      throw new PTClaimError(
+        "NONCE_READ_FAILED",
+        `failed to read mintRequestNonces(${request.userAddress}): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const nonceKey = `${(0, import_viem10.getAddress)(request.userAddress).toLowerCase()}:${request.pointTokenAddress.toLowerCase()}`;
+    let userNonces = this.inFlightNonces.get(nonceKey);
+    if (!userNonces) {
+      userNonces = /* @__PURE__ */ new Set();
+      this.inFlightNonces.set(nonceKey, userNonces);
+    }
+    if (userNonces.has(mintRequestNonce)) {
+      throw new PTClaimError(
+        "NONCE_IN_FLIGHT",
+        `concurrent claim for nonce ${mintRequestNonce} in progress; retry after the prior request completes`,
+        { userAddress: request.userAddress, pointToken: request.pointTokenAddress, nonce: mintRequestNonce.toString() }
+      );
+    }
+    userNonces.add(mintRequestNonce);
     const wrapperOverride = this.cfg.mintFeeWrapperAddress;
     const wrapperFromSdk = chainAddresses.mintFeeWrapper;
     const resolvedWrapper = wrapperOverride !== void 0 ? isNoWrapper2(wrapperOverride) ? void 0 : wrapperOverride : isNoWrapper2(wrapperFromSdk) ? void 0 : wrapperFromSdk;
-    const lockId = await this.cfg.ledger.lockForMinting(
-      request.userAddress,
-      request.amount,
-      this.cfg.lockDurationMs,
-      request.pointTokenAddress
-    );
     try {
-      const signatureDeadline = BigInt(
-        Math.floor(this.cfg.now() / 1e3) + this.cfg.signatureDeadlineSeconds
-      );
-      const previewUserOp = this.cfg.relayService.previewMintUserOp({
-        userAddress: request.userAddress,
-        aaNonce: request.aaNonce,
-        pointTokenAddress: request.pointTokenAddress,
-        amount: request.amount,
-        deadline: signatureDeadline,
-        mintFeeWrapperAddress: resolvedWrapper
-      });
-      const feeAmount = this.cfg.feeService ? await this.cfg.feeService.estimateGasFee({
-        scenario: resolvedWrapper ? "mint-wrapped" : "mint",
-        contractAddress: request.pointTokenAddress,
-        partialUserOp: {
-          sender: previewUserOp.sender,
-          nonce: previewUserOp.nonce,
-          callData: previewUserOp.callData
-        }
-      }) : 0n;
-      const domainName = await this.cfg.domainResolver.resolve(
+      const lockCreatedAtMs = this.cfg.now();
+      const lockExpiresAtMs = lockCreatedAtMs + this.cfg.lockDurationMs;
+      const lockId = await this.cfg.ledger.lockForMinting(
+        request.userAddress,
+        request.amount,
+        this.cfg.lockDurationMs,
         request.pointTokenAddress
       );
-      const domain = {
-        name: domainName,
-        chainId: request.chainId,
-        verifyingContract: request.pointTokenAddress
-      };
-      let userOp;
       try {
-        userOp = await this.cfg.relayService.prepareMint({
+        const requestedDeadlineSec = Math.floor(lockCreatedAtMs / 1e3) + this.cfg.signatureDeadlineSeconds;
+        const lockBoundedDeadlineSec = Math.floor(
+          (lockExpiresAtMs - M11_SAFETY_MARGIN_MS2) / 1e3
+        );
+        const signatureDeadline = BigInt(
+          Math.min(requestedDeadlineSec, lockBoundedDeadlineSec)
+        );
+        const previewUserOp = this.cfg.relayService.previewMintUserOp({
           userAddress: request.userAddress,
           aaNonce: request.aaNonce,
-          batchExecutorAddress,
           pointTokenAddress: request.pointTokenAddress,
           amount: request.amount,
-          issuerSignerWallet: this.cfg.issuerSignerWallet,
-          domain,
-          mintRequestNonce: request.mintRequestNonce,
           deadline: signatureDeadline,
-          mintFeeWrapperAddress: resolvedWrapper,
-          // Pass the bundler-estimated `feeAmount` explicitly so the
-          // RelayService skips its legacy `quoteOperatorFeePt` path
-          // (which uses the SDK's old 12_000 bps premium default).
-          // Without this, the response's `feeAmount` (from FeeManager,
-          // 100% premium on top of PAFI's 110% server-side estimate)
-          // would diverge from the actual PT.transfer amount in the
-          // UserOp batch (`quoteOperatorFeePt`'s 120%), and the user
-          // would see one value while the wallet transferred another.
-          feeAmount
+          mintFeeWrapperAddress: resolvedWrapper
         });
-      } catch (err) {
-        throw new PTClaimError(
-          "BUILD_FAILED",
-          `prepareMint failed: ${err instanceof Error ? err.message : String(err)}`
+        const feeAmount = this.cfg.feeService ? await this.cfg.feeService.estimateGasFee({
+          scenario: resolvedWrapper ? "mint-wrapped" : "mint",
+          contractAddress: request.pointTokenAddress,
+          partialUserOp: {
+            sender: previewUserOp.sender,
+            nonce: previewUserOp.nonce,
+            callData: previewUserOp.callData
+          }
+        }) : 0n;
+        const domainName = await this.cfg.domainResolver.resolve(
+          request.pointTokenAddress
         );
-      }
-      let fallback;
-      if (feeAmount > 0n) {
+        const domain = {
+          name: domainName,
+          chainId: request.chainId,
+          verifyingContract: request.pointTokenAddress
+        };
+        let userOp;
         try {
-          fallback = await this.cfg.relayService.prepareMint({
+          userOp = await this.cfg.relayService.prepareMint({
             userAddress: request.userAddress,
             aaNonce: request.aaNonce,
             batchExecutorAddress,
@@ -3219,34 +3252,68 @@ var PTClaimHandler = class {
             amount: request.amount,
             issuerSignerWallet: this.cfg.issuerSignerWallet,
             domain,
-            mintRequestNonce: request.mintRequestNonce,
+            mintRequestNonce,
             deadline: signatureDeadline,
-            feeAmount: 0n,
-            mintFeeWrapperAddress: resolvedWrapper
+            mintFeeWrapperAddress: resolvedWrapper,
+            // Pass the bundler-estimated `feeAmount` explicitly so the
+            // RelayService skips its legacy `quoteOperatorFeePt` path
+            // (which uses the SDK's old 12_000 bps premium default).
+            // Without this, the response's `feeAmount` (from FeeManager,
+            // 100% premium on top of PAFI's 110% server-side estimate)
+            // would diverge from the actual PT.transfer amount in the
+            // UserOp batch (`quoteOperatorFeePt`'s 120%), and the user
+            // would see one value while the wallet transferred another.
+            feeAmount
           });
         } catch (err) {
           throw new PTClaimError(
             "BUILD_FAILED",
-            `prepareMint (fallback) failed: ${err instanceof Error ? err.message : String(err)}`
+            `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,
+              deadline: signatureDeadline,
+              feeAmount: 0n,
+              mintFeeWrapperAddress: resolvedWrapper
+            });
+          } catch (err) {
+            throw new PTClaimError(
+              "BUILD_FAILED",
+              `prepareMint (fallback) failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        const calls = (0, import_core11.decodeBatchExecuteCalls)(userOp.callData);
+        const callsFallback = fallback ? (0, import_core11.decodeBatchExecuteCalls)(fallback.callData) : void 0;
+        return {
+          userOp,
+          fallback,
+          lockId,
+          feeAmount,
+          signatureDeadline,
+          expiresInSeconds: Math.floor(this.cfg.lockDurationMs / 1e3),
+          calls,
+          callsFallback
+        };
+      } catch (err) {
+        await this.cfg.ledger.releaseLock(lockId).catch(() => {
+        });
+        throw err;
       }
-      const calls = (0, import_core11.decodeBatchExecuteCalls)(userOp.callData);
-      const callsFallback = fallback ? (0, import_core11.decodeBatchExecuteCalls)(fallback.callData) : void 0;
-      return {
-        userOp,
-        fallback,
-        lockId,
-        feeAmount,
-        signatureDeadline,
-        expiresInSeconds: Math.floor(this.cfg.lockDurationMs / 1e3),
-        calls,
-        callsFallback
-      };
-    } catch (err) {
-      await this.cfg.ledger.releaseLock(lockId).catch(() => {
-      });
-      throw err;
+    } finally {
+      userNonces.delete(mintRequestNonce);
+      if (userNonces.size === 0) this.inFlightNonces.delete(nonceKey);
     }
   }
 };
@@ -3561,7 +3628,6 @@ var IssuerApiAdapter = class {
       }
     );
     return {
-      mintRequestNonce: result.mintRequestNonce.toString(),
       offChainBalance: result.offChainBalance.toString(),
       onChainBalance: result.onChainBalance.toString(),
       totalBalance: result.totalBalance.toString(),
@@ -3585,8 +3651,7 @@ var IssuerApiAdapter = class {
       amount: input.amount,
       pointTokenAddress,
       chainId: input.chainId,
-      aaNonce: input.aaNonce,
-      mintRequestNonce: input.mintRequestNonce
+      aaNonce: input.aaNonce
     });
     const sponsorAuth = await this.buildSponsorAuth(
       input.authenticatedAddress,
@@ -3682,8 +3747,7 @@ var IssuerApiAdapter = class {
       amount: input.amount,
       pointTokenAddress,
       chainId: input.chainId,
-      aaNonce: input.aaNonce,
-      mintRequestNonce: input.mintRequestNonce
+      aaNonce: input.aaNonce
     });
     const prepared = await this.runMobilePrepare(
       input.authenticatedAddress,
@@ -5142,7 +5206,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.24.1" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.25.0" : "dev";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdapterMisconfiguredError,