@pafi-dev/issuer 0.10.2 → 0.11.1

package/dist/index.d.cts

@@ -814,6 +814,22 @@ interface PointIndexerConfig {
     provider: PublicClient;
     pointTokenAddress: Address;
     ledger: IPointLedger;
+    /**
+     * v1.6 — when set, indexer listens to `MintFeeWrapper.MintWithFee`
+     * (filtered by this `pointToken`) instead of `PointToken.Transfer(0x0)`.
+     *
+     * Required for wrapper-mediated mints because the on-chain Transfer
+     * destination is the wrapper itself (not the end user), so a naive
+     * `Transfer(0x0 → user)` watch would leave PENDING locks unresolved.
+     *
+     * `MintWithFee(indexed pointToken, indexed to, grossAmount, netAmount,
+     * feeAmount)` carries the actual recipient + the gross amount that
+     * matches the off-chain lock.
+     *
+     * Pass `undefined` (or the dead-zero address) for direct-mint chains
+     * without a wrapper — indexer falls back to legacy Transfer mode.
+     */
+    mintFeeWrapperAddress?: Address;
     /**
      * Block to start from on first run. Ignored if the cursor store already
      * has a value. Defaults to `0n`.
@@ -853,8 +869,20 @@ interface PointIndexerConfig {
     onTickError?: (err: unknown) => void;
 }
 /**
- * Watches `PointToken.Transfer(from=0x0 → to)` events and finalizes the
- * issuer ledger on each confirmed mint.
+ * Watches mint events on PointToken and finalizes the issuer ledger when
+ * a confirmed mint matches a PENDING lock.
+ *
+ * **Two modes** — selected at construction by `mintFeeWrapperAddress`:
+ *
+ * 1. **Wrapper mode (v1.6, recommended for mainnet)**
+ *    Listens to `MintFeeWrapper.MintWithFee(indexed pointToken, indexed to,
+ *    grossAmount, netAmount, feeAmount)` filtered by `pointToken`. The
+ *    `to` field is the actual end-user (not the wrapper), and `grossAmount`
+ *    matches the off-chain lock's amount.
+ *
+ * 2. **Direct mode (legacy / chains without wrapper)**
+ *    Listens to `PointToken.Transfer(from=0x0 → to)` — the original v1.5
+ *    behavior. Used when the wrapper address is undefined / zero / dead.
  *
  * Finalization strategy (per event):
  *   1. Find a PENDING locked mint request for `to` with matching amount.
@@ -876,6 +904,7 @@ interface PointIndexerConfig {
 declare class PointIndexer {
     private readonly provider;
     private readonly pointTokenAddress;
+    private readonly mintFeeWrapperAddress;
     private readonly ledger;
     private readonly cursorStore;
     private readonly startBlock;
@@ -904,7 +933,18 @@ declare class PointIndexer {
      * engaging `start()`. On completion, the cursor is advanced to `to + 1`.
      */
     processBlockRange(from: bigint, to: bigint): Promise<void>;
-    private decodeMintEvents;
+    /**
+     * 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.
+     */
+    private fetchWrapperMintEvents;
+    /**
+     * Direct mode (legacy / chains without wrapper): listen for
+     * `Transfer(from=0x0 → to)` on the PointToken itself.
+     */
+    private fetchTransferMintEvents;
+    private decodeTransferMintEvents;
     /**
      * Finalize a single mint event: match it to a PENDING lock in the
      * ledger, then call `deductBalance` (which also resolves the lock in
@@ -2550,6 +2590,14 @@ interface IssuerServiceConfig {
          * Default: `false` — the caller decides when to begin polling.
          */
         autoStart?: boolean;
+        /**
+         * v1.6 — override the MintFeeWrapper address used by the indexer.
+         * When omitted, the factory auto-resolves from
+         * `getContractAddresses(chainId).mintFeeWrapper`. Pass the
+         * dead-zero address (`0x...dEaD`) to force direct-Transfer mode
+         * (legacy v1.5, useful for local fork tests).
+         */
+        mintFeeWrapperAddress?: Address;
     };
     /**
      * Redemption restriction config. When provided, the SDK fetches the

package/dist/index.d.ts

@@ -814,6 +814,22 @@ interface PointIndexerConfig {
     provider: PublicClient;
     pointTokenAddress: Address;
     ledger: IPointLedger;
+    /**
+     * v1.6 — when set, indexer listens to `MintFeeWrapper.MintWithFee`
+     * (filtered by this `pointToken`) instead of `PointToken.Transfer(0x0)`.
+     *
+     * Required for wrapper-mediated mints because the on-chain Transfer
+     * destination is the wrapper itself (not the end user), so a naive
+     * `Transfer(0x0 → user)` watch would leave PENDING locks unresolved.
+     *
+     * `MintWithFee(indexed pointToken, indexed to, grossAmount, netAmount,
+     * feeAmount)` carries the actual recipient + the gross amount that
+     * matches the off-chain lock.
+     *
+     * Pass `undefined` (or the dead-zero address) for direct-mint chains
+     * without a wrapper — indexer falls back to legacy Transfer mode.
+     */
+    mintFeeWrapperAddress?: Address;
     /**
      * Block to start from on first run. Ignored if the cursor store already
      * has a value. Defaults to `0n`.
@@ -853,8 +869,20 @@ interface PointIndexerConfig {
     onTickError?: (err: unknown) => void;
 }
 /**
- * Watches `PointToken.Transfer(from=0x0 → to)` events and finalizes the
- * issuer ledger on each confirmed mint.
+ * Watches mint events on PointToken and finalizes the issuer ledger when
+ * a confirmed mint matches a PENDING lock.
+ *
+ * **Two modes** — selected at construction by `mintFeeWrapperAddress`:
+ *
+ * 1. **Wrapper mode (v1.6, recommended for mainnet)**
+ *    Listens to `MintFeeWrapper.MintWithFee(indexed pointToken, indexed to,
+ *    grossAmount, netAmount, feeAmount)` filtered by `pointToken`. The
+ *    `to` field is the actual end-user (not the wrapper), and `grossAmount`
+ *    matches the off-chain lock's amount.
+ *
+ * 2. **Direct mode (legacy / chains without wrapper)**
+ *    Listens to `PointToken.Transfer(from=0x0 → to)` — the original v1.5
+ *    behavior. Used when the wrapper address is undefined / zero / dead.
  *
  * Finalization strategy (per event):
  *   1. Find a PENDING locked mint request for `to` with matching amount.
@@ -876,6 +904,7 @@ interface PointIndexerConfig {
 declare class PointIndexer {
     private readonly provider;
     private readonly pointTokenAddress;
+    private readonly mintFeeWrapperAddress;
     private readonly ledger;
     private readonly cursorStore;
     private readonly startBlock;
@@ -904,7 +933,18 @@ declare class PointIndexer {
      * engaging `start()`. On completion, the cursor is advanced to `to + 1`.
      */
     processBlockRange(from: bigint, to: bigint): Promise<void>;
-    private decodeMintEvents;
+    /**
+     * 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.
+     */
+    private fetchWrapperMintEvents;
+    /**
+     * Direct mode (legacy / chains without wrapper): listen for
+     * `Transfer(from=0x0 → to)` on the PointToken itself.
+     */
+    private fetchTransferMintEvents;
+    private decodeTransferMintEvents;
     /**
      * Finalize a single mint event: match it to a PENDING lock in the
      * ledger, then call `deductBalance` (which also resolves the lock in
@@ -2550,6 +2590,14 @@ interface IssuerServiceConfig {
          * Default: `false` — the caller decides when to begin polling.
          */
         autoStart?: boolean;
+        /**
+         * v1.6 — override the MintFeeWrapper address used by the indexer.
+         * When omitted, the factory auto-resolves from
+         * `getContractAddresses(chainId).mintFeeWrapper`. Pass the
+         * dead-zero address (`0x...dEaD`) to force direct-Transfer mode
+         * (legacy v1.5, useful for local fork tests).
+         */
+        mintFeeWrapperAddress?: Address;
     };
     /**
      * Redemption restriction config. When provided, the SDK fetches the

package/dist/index.js

@@ -924,13 +924,23 @@ import { getAddress as getAddress3, parseAbiItem } from "viem";
 var TRANSFER_EVENT = parseAbiItem(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
+var MINT_WITH_FEE_EVENT = 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 = getAddress3(addr);
+  return checksummed === ZERO_ADDRESS || checksummed === DEAD_ADDRESS;
+}
 var PointIndexer = class {
   provider;
   pointTokenAddress;
+  mintFeeWrapperAddress;
   ledger;
   cursorStore;
   startBlock;
@@ -946,7 +956,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 = getAddress3(config.pointTokenAddress);
+    this.mintFeeWrapperAddress = isNoWrapper(config.mintFeeWrapperAddress) ? void 0 : getAddress3(config.mintFeeWrapperAddress);
     this.ledger = config.ledger;
     this.cursorStore = config.cursorStore ?? new InMemoryCursorStore();
     this.startBlock = config.fromBlock ?? 0n;
@@ -1029,14 +1040,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;
@@ -1051,9 +1055,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 (getAddress3(args.pointToken) !== this.pointTokenAddress) continue;
+      out.push({
+        to: getAddress3(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;
@@ -1070,6 +1118,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
@@ -2380,7 +2431,7 @@ var PTClaimError = class extends PafiSdkError {
     this.details = details;
   }
 };
-function isNoWrapper(address) {
+function isNoWrapper2(address) {
   if (!address) return true;
   const lower = address.toLowerCase();
   return lower === "0x0000000000000000000000000000000000000000" || lower === "0x000000000000000000000000000000000000dead";
@@ -2425,7 +2476,7 @@ var PTClaimHandler = class {
     const { batchExecutor: batchExecutorAddress } = chainAddresses;
     const wrapperOverride = this.cfg.mintFeeWrapperAddress;
     const wrapperFromSdk = chainAddresses.mintFeeWrapper;
-    const resolvedWrapper = wrapperOverride !== void 0 ? isNoWrapper(wrapperOverride) ? void 0 : wrapperOverride : isNoWrapper(wrapperFromSdk) ? void 0 : wrapperFromSdk;
+    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,
@@ -4140,6 +4191,9 @@ function createIssuerService(config) {
       provider: config.provider
     });
   }
+  const sdkWrapperAddress = getContractAddresses7(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 = {
@@ -4147,6 +4201,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;
     }
@@ -4421,7 +4478,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.10.2" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.11.0" : "dev";
 export {
   AdapterMisconfiguredError,
   AuthError,