@pafi-dev/issuer 0.23.0 → 0.25.0

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   BundlerNotConfiguredError: () => BundlerNotConfiguredError,
   BundlerRejectedError: () => BundlerRejectedError,
   BurnIndexer: () => BurnIndexer,
+  BurnIndexerFinalizeError: () => BurnIndexerFinalizeError,
   ConfigurationError: () => ConfigurationError,
   DEFAULT_REDEMPTION_POLICY: () => DEFAULT_REDEMPTION_POLICY,
   DefaultPolicyEngine: () => DefaultPolicyEngine,
@@ -57,6 +58,7 @@ __export(index_exports, {
   PerpDepositError: () => PerpDepositError,
   PerpDepositHandler: () => PerpDepositHandler,
   PointIndexer: () => PointIndexer,
+  PointIndexerFinalizeError: () => PointIndexerFinalizeError,
   PointTokenDomainResolver: () => PointTokenDomainResolver,
   PolicyProvider: () => PolicyProvider,
   REDEMPTION_HISTORY_WINDOW_SEC: () => REDEMPTION_HISTORY_WINDOW_SEC,
@@ -908,6 +910,7 @@ var RelayService = class {
         "prepareMint: deadline exceeds maximum allowed window (1 hour)"
       );
     }
+    const MINT_SOURCE = import_core5.Source.EQUITY;
     const useWrapper = params.mintFeeWrapperAddress !== void 0;
     const receiverForSig = useWrapper ? params.mintFeeWrapperAddress : params.userAddress;
     let minterSig;
@@ -919,6 +922,7 @@ var RelayService = class {
           user: params.userAddress,
           receiver: receiverForSig,
           amount: params.amount,
+          source: MINT_SOURCE,
           nonce: params.mintRequestNonce,
           deadline: params.deadline
         }
@@ -949,9 +953,15 @@ var RelayService = class {
         mintTarget = params.mintFeeWrapperAddress;
       } else {
         mintCallData = (0, import_viem3.encodeFunctionData)({
-          abi: import_core5.POINT_TOKEN_ABI,
+          abi: import_core5.POINT_TOKEN_MINT_SIG_ABI,
           functionName: "mint",
-          args: [params.userAddress, params.amount, params.deadline, minterSig]
+          args: [
+            params.userAddress,
+            params.amount,
+            MINT_SOURCE,
+            params.deadline,
+            minterSig
+          ]
         });
         mintTarget = params.pointTokenAddress;
       }
@@ -1036,11 +1046,12 @@ var RelayService = class {
     let burnCallData;
     try {
       burnCallData = (0, import_viem3.encodeFunctionData)({
-        abi: import_core5.POINT_TOKEN_ABI,
+        abi: import_core5.POINT_TOKEN_BURN_SIG_ABI,
         functionName: "burn",
         args: [
           params.burnRequest.from,
           params.burnRequest.amount,
+          params.burnRequest.source,
           params.burnRequest.deadline,
           params.burnerSignature
         ]
@@ -1135,11 +1146,12 @@ var RelayService = class {
       mintTarget = params.mintFeeWrapperAddress;
     } else {
       mintCallData = (0, import_viem3.encodeFunctionData)({
-        abi: import_core5.POINT_TOKEN_ABI,
+        abi: import_core5.POINT_TOKEN_MINT_SIG_ABI,
         functionName: "mint",
         args: [
           params.userAddress,
           params.amount,
+          import_core5.Source.EQUITY,
           params.deadline,
           PLACEHOLDER_SIG_65
         ]
@@ -1161,11 +1173,12 @@ var RelayService = class {
   /** Burn-side mirror of `previewMintUserOp`. */
   previewBurnUserOp(params) {
     const burnCallData = (0, import_viem3.encodeFunctionData)({
-      abi: import_core5.POINT_TOKEN_ABI,
+      abi: import_core5.POINT_TOKEN_BURN_SIG_ABI,
       functionName: "burn",
       args: [
         params.userAddress,
         params.amount,
+        import_core5.Source.EQUITY,
         params.deadline,
         PLACEHOLDER_SIG_65
       ]
@@ -1383,6 +1396,16 @@ var InMemoryCursorStore = class _InMemoryCursorStore {
 
 // src/indexer/pointIndexer.ts
 var import_viem4 = require("viem");
+var PointIndexerFinalizeError = class extends Error {
+  constructor(message, context, cause) {
+    super(message);
+    this.context = context;
+    this.cause = cause;
+    this.name = "PointIndexerFinalizeError";
+  }
+  context;
+  cause;
+};
 var TRANSFER_EVENT = (0, import_viem4.parseAbiItem)(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
@@ -1608,8 +1631,18 @@ var PointIndexer = class {
         evt.txHash,
         this.pointTokenAddress
       );
-    } catch {
-      return;
+    } catch (err) {
+      throw new PointIndexerFinalizeError(
+        `PointIndexer.deductBalance failed for tx ${evt.txHash} (to=${evt.to}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`,
+        {
+          pointToken: this.pointTokenAddress,
+          to: evt.to,
+          amount: evt.amount,
+          txHash: evt.txHash,
+          blockNumber: evt.blockNumber
+        },
+        err
+      );
     }
     try {
       await this.ledger.updateMintStatus(match.lockId, "MINTED", evt.txHash);
@@ -1631,6 +1664,16 @@ function pickMatchingLock(locks, amount) {
 
 // src/indexer/burnIndexer.ts
 var import_viem5 = require("viem");
+var BurnIndexerFinalizeError = class extends Error {
+  constructor(message, context, cause) {
+    super(message);
+    this.context = context;
+    this.cause = cause;
+    this.name = "BurnIndexerFinalizeError";
+  }
+  context;
+  cause;
+};
 var TRANSFER_EVENT2 = (0, import_viem5.parseAbiItem)(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
@@ -1798,7 +1841,18 @@ var BurnIndexer = class {
     try {
       await this.ledger.resolveCreditByBurnTx(lockId, evt.txHash);
     } catch (err) {
-      console.error("[PAFI] BurnIndexer finalize error \u2014 credit may be lost:", err);
+      throw new BurnIndexerFinalizeError(
+        `BurnIndexer.resolveCreditByBurnTx failed for tx ${evt.txHash} (lockId=${lockId}, from=${evt.from}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`,
+        {
+          pointToken: this.pointTokenAddress,
+          from: evt.from,
+          amount: evt.amount,
+          txHash: evt.txHash,
+          blockNumber: evt.blockNumber,
+          lockId
+        },
+        err
+      );
     }
   }
 };
@@ -2113,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,
@@ -2257,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;
@@ -2324,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;
     }
@@ -2389,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) {
@@ -2398,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
@@ -2440,10 +2506,12 @@ var PTRedeemHandler = class {
       chainId: this.chainId,
       verifyingContract: pointTokenAddress
     };
+    const BURN_SOURCE = import_core7.Source.EQUITY;
     const sponsoredBurnAmount = request.amount - fee;
     const sponsoredBurnRequest = {
       from: request.userAddress,
       amount: sponsoredBurnAmount,
+      source: BURN_SOURCE,
       nonce: burnNonce,
       deadline
     };
@@ -2479,6 +2547,7 @@ var PTRedeemHandler = class {
         const fallbackBurnRequest = {
           from: request.userAddress,
           amount: request.amount,
+          source: BURN_SOURCE,
           nonce: burnNonce,
           deadline
         };
@@ -3047,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())
     };
   }
@@ -3084,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,
@@ -3162,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);
     }
   }
 };
@@ -3504,7 +3628,6 @@ var IssuerApiAdapter = class {
       }
     );
     return {
-      mintRequestNonce: result.mintRequestNonce.toString(),
       offChainBalance: result.offChainBalance.toString(),
       onChainBalance: result.onChainBalance.toString(),
       totalBalance: result.totalBalance.toString(),
@@ -3528,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,
@@ -3625,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,
@@ -4990,22 +5111,22 @@ var IssuerStateValidator = class _IssuerStateValidator {
       }
       throw err;
     }
-    const { issuer, totalSupply, hardCap, remaining } = state;
+    const { issuer, equityCap, equitySupply, remaining } = state;
     if (!issuer.active) {
       throw new IssuerStateError(
         "ISSUER_INACTIVE",
-        `Issuer ${issuer.issuerAddress} is deactivated on IssuerRegistry`,
-        { issuer: issuer.issuerAddress, pointToken: issuer.pointToken }
+        `Issuer "${issuer.name}" is deactivated on IssuerRegistry`,
+        { pointToken }
       );
     }
-    if (totalSupply + amount > hardCap) {
+    if (equitySupply + amount > equityCap.hardCap) {
       throw new IssuerStateError(
         "MINT_CAP_EXCEEDED",
-        `Requested ${amount} PT would exceed mint cap. Cap=${hardCap}, minted=${totalSupply}, remaining=${remaining}`,
+        `Requested ${amount} PT would exceed EQUITY mint cap. Cap=${equityCap.hardCap}, equityMinted=${equitySupply}, remaining=${remaining}`,
         {
           requested: amount.toString(),
-          cap: hardCap.toString(),
-          minted: totalSupply.toString(),
+          cap: equityCap.hardCap.toString(),
+          equityMinted: equitySupply.toString(),
           remaining: remaining.toString()
         }
       );
@@ -5021,33 +5142,28 @@ var IssuerStateValidator = class _IssuerStateValidator {
       args: [issuerAddr]
     });
     const issuer = {
-      issuerAddress: issuerStruct.issuerAddress,
       signerAddress: issuerStruct.signerAddress,
       name: issuerStruct.name,
-      symbol: issuerStruct.symbol,
       active: issuerStruct.active,
-      pointToken: issuerStruct.pointToken,
-      mintingOracle: issuerStruct.mintingOracle
+      capitalBase: issuerStruct.capitalBase,
+      basisPoints: Number(issuerStruct.basisPoints)
     };
-    const [tokenCap, totalSupply] = await Promise.all([
-      (0, import_core19.getTokenCap)(this.provider, issuer.mintingOracle, tokenAddr),
-      this.provider.readContract({
-        address: tokenAddr,
-        abi: import_core19.POINT_TOKEN_ABI,
-        functionName: "totalSupply"
-      })
-    ]);
-    const tokenCapRecord = {
-      declaredTotalSupply: tokenCap.declaredTotalSupply,
-      capBasisPoints: tokenCap.capBasisPoints
+    const equitySupply = await this.provider.readContract({
+      address: tokenAddr,
+      abi: import_core19.POINT_TOKEN_ABI,
+      functionName: "equitySupply"
+    });
+    const hardCap = issuer.capitalBase * BigInt(issuer.basisPoints) / 10000n;
+    const equityCap = {
+      capitalBase: issuer.capitalBase,
+      basisPoints: issuer.basisPoints,
+      hardCap
     };
-    const hardCap = tokenCapRecord.declaredTotalSupply * BigInt(tokenCapRecord.capBasisPoints) / 10000n;
-    const remaining = hardCap > totalSupply ? hardCap - totalSupply : 0n;
+    const remaining = hardCap > equitySupply ? hardCap - equitySupply : 0n;
     return {
       issuer,
-      tokenCap: tokenCapRecord,
-      totalSupply,
-      hardCap,
+      equityCap,
+      equitySupply,
       remaining
     };
   }
@@ -5090,7 +5206,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.23.0" : "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,
@@ -5099,6 +5215,7 @@ var PAFI_ISSUER_SDK_VERSION = true ? "0.23.0" : "dev";
   BundlerNotConfiguredError,
   BundlerRejectedError,
   BurnIndexer,
+  BurnIndexerFinalizeError,
   ConfigurationError,
   DEFAULT_REDEMPTION_POLICY,
   DefaultPolicyEngine,
@@ -5130,6 +5247,7 @@ var PAFI_ISSUER_SDK_VERSION = true ? "0.23.0" : "dev";
   PerpDepositError,
   PerpDepositHandler,
   PointIndexer,
+  PointIndexerFinalizeError,
   PointTokenDomainResolver,
   PolicyProvider,
   REDEMPTION_HISTORY_WINDOW_SEC,