@pafi-dev/issuer 0.10.1 → 0.11.0

package/dist/index.cjs

@@ -1155,13 +1155,23 @@ var import_viem4 = require("viem");
 var TRANSFER_EVENT = (0, import_viem4.parseAbiItem)(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
+var MINT_WITH_FEE_EVENT = (0, import_viem4.parseAbiItem)(
+  "event MintWithFee(address indexed pointToken, address indexed to, uint256 grossAmount, uint256 netAmount, uint256 feeAmount)"
+);
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
 var DEFAULT_CONFIRMATIONS = 3;
 var DEFAULT_BATCH_SIZE = 2000n;
 var DEFAULT_POLL_INTERVAL_MS = 5e3;
+function isNoWrapper(addr) {
+  if (!addr) return true;
+  const checksummed = (0, import_viem4.getAddress)(addr);
+  return checksummed === ZERO_ADDRESS || checksummed === DEAD_ADDRESS;
+}
 var PointIndexer = class {
   provider;
   pointTokenAddress;
+  mintFeeWrapperAddress;
   ledger;
   cursorStore;
   startBlock;
@@ -1177,7 +1187,8 @@ var PointIndexer = class {
       throw new Error("PointIndexer: pointTokenAddress required");
     if (!config.ledger) throw new Error("PointIndexer: ledger required");
     this.provider = config.provider;
-    this.pointTokenAddress = config.pointTokenAddress;
+    this.pointTokenAddress = (0, import_viem4.getAddress)(config.pointTokenAddress);
+    this.mintFeeWrapperAddress = isNoWrapper(config.mintFeeWrapperAddress) ? void 0 : (0, import_viem4.getAddress)(config.mintFeeWrapperAddress);
     this.ledger = config.ledger;
     this.cursorStore = config.cursorStore ?? new InMemoryCursorStore();
     this.startBlock = config.fromBlock ?? 0n;
@@ -1260,14 +1271,7 @@ var PointIndexer = class {
     let cursor = from;
     while (cursor <= to) {
       const chunkEnd = cursor + this.batchSize - 1n > to ? to : cursor + this.batchSize - 1n;
-      const logs = await this.provider.getLogs({
-        address: this.pointTokenAddress,
-        event: TRANSFER_EVENT,
-        args: { from: ZERO_ADDRESS },
-        fromBlock: cursor,
-        toBlock: chunkEnd
-      });
-      const events = this.decodeMintEvents(logs);
+      const events = this.mintFeeWrapperAddress ? await this.fetchWrapperMintEvents(cursor, chunkEnd) : await this.fetchTransferMintEvents(cursor, chunkEnd);
       events.sort((a, b) => {
         if (a.blockNumber !== b.blockNumber) {
           return a.blockNumber < b.blockNumber ? -1 : 1;
@@ -1282,9 +1286,53 @@ var PointIndexer = class {
     }
   }
   // -------------------------------------------------------------------------
-  // Internals
+  // Event fetching — two modes (wrapper vs direct)
   // -------------------------------------------------------------------------
-  decodeMintEvents(logs) {
+  /**
+   * Wrapper mode (v1.6): listen for `MintWithFee` on the wrapper,
+   * filtered to events for THIS pointToken only. The event's `to` field
+   * is the actual end user, and `grossAmount` matches the lock amount.
+   */
+  async fetchWrapperMintEvents(fromBlock, toBlock) {
+    const logs = await this.provider.getLogs({
+      address: this.mintFeeWrapperAddress,
+      event: MINT_WITH_FEE_EVENT,
+      args: { pointToken: this.pointTokenAddress },
+      fromBlock,
+      toBlock
+    });
+    const out = [];
+    for (const log of logs) {
+      const args = log.args;
+      if (!args.pointToken || !args.to || args.grossAmount === void 0 || log.blockNumber === null || log.transactionHash === null) {
+        continue;
+      }
+      if ((0, import_viem4.getAddress)(args.pointToken) !== this.pointTokenAddress) continue;
+      out.push({
+        to: (0, import_viem4.getAddress)(args.to),
+        amount: args.grossAmount,
+        blockNumber: log.blockNumber,
+        txHash: log.transactionHash,
+        logIndex: log.logIndex ?? 0
+      });
+    }
+    return out;
+  }
+  /**
+   * Direct mode (legacy / chains without wrapper): listen for
+   * `Transfer(from=0x0 → to)` on the PointToken itself.
+   */
+  async fetchTransferMintEvents(fromBlock, toBlock) {
+    const logs = await this.provider.getLogs({
+      address: this.pointTokenAddress,
+      event: TRANSFER_EVENT,
+      args: { from: ZERO_ADDRESS },
+      fromBlock,
+      toBlock
+    });
+    return this.decodeTransferMintEvents(logs);
+  }
+  decodeTransferMintEvents(logs) {
     const out = [];
     for (const log of logs) {
       const args = log.args;
@@ -1301,6 +1349,9 @@ var PointIndexer = class {
     }
     return out;
   }
+  // -------------------------------------------------------------------------
+  // Finalization
+  // -------------------------------------------------------------------------
   /**
    * Finalize a single mint event: match it to a PENDING lock in the
    * ledger, then call `deductBalance` (which also resolves the lock in
@@ -2592,6 +2643,11 @@ var PTClaimError = class extends import_core.PafiSdkError {
     this.details = details;
   }
 };
+function isNoWrapper2(address) {
+  if (!address) return true;
+  const lower = address.toLowerCase();
+  return lower === "0x0000000000000000000000000000000000000000" || lower === "0x000000000000000000000000000000000000dead";
+}
 var DEFAULT_LOCK_MS = 15 * 60 * 1e3;
 var DEFAULT_SIG_DEADLINE_SEC2 = 15 * 60;
 var PTClaimHandler = class {
@@ -2628,9 +2684,11 @@ var PTClaimHandler = class {
         );
       }
     }
-    const { batchExecutor: batchExecutorAddress } = (0, import_core11.getContractAddresses)(
-      request.chainId
-    );
+    const chainAddresses = (0, import_core11.getContractAddresses)(request.chainId);
+    const { batchExecutor: batchExecutorAddress } = chainAddresses;
+    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,
@@ -2659,7 +2717,7 @@ var PTClaimHandler = class {
           domain,
           mintRequestNonce: request.mintRequestNonce,
           deadline: signatureDeadline,
-          mintFeeWrapperAddress: this.cfg.mintFeeWrapperAddress
+          mintFeeWrapperAddress: resolvedWrapper
           // No feeAmount/feeRecipient — RelayService auto-resolves.
         });
       } catch (err) {
@@ -2682,7 +2740,7 @@ var PTClaimHandler = class {
             mintRequestNonce: request.mintRequestNonce,
             deadline: signatureDeadline,
             feeAmount: 0n,
-            mintFeeWrapperAddress: this.cfg.mintFeeWrapperAddress
+            mintFeeWrapperAddress: resolvedWrapper
           });
         } catch (err) {
           throw new PTClaimError(
@@ -4317,6 +4375,9 @@ function createIssuerService(config) {
       provider: config.provider
     });
   }
+  const sdkWrapperAddress = (0, import_core19.getContractAddresses)(config.chainId).mintFeeWrapper;
+  const wrapperOverride = config.indexer?.mintFeeWrapperAddress;
+  const resolvedWrapperAddress = wrapperOverride !== void 0 ? wrapperOverride : sdkWrapperAddress;
   const indexers = /* @__PURE__ */ new Map();
   for (const tokenAddress of tokenAddresses) {
     const indexerConfig = {
@@ -4324,6 +4385,9 @@ function createIssuerService(config) {
       pointTokenAddress: tokenAddress,
       ledger
     };
+    if (resolvedWrapperAddress !== void 0) {
+      indexerConfig.mintFeeWrapperAddress = resolvedWrapperAddress;
+    }
     if (config.indexer?.fromBlock !== void 0) {
       indexerConfig.fromBlock = config.indexer.fromBlock;
     }
@@ -4594,7 +4658,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.10.1" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.11.0" : "dev";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdapterMisconfiguredError,