@pafi-dev/issuer 0.10.1 → 0.11.0

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
@@ -2238,13 +2278,20 @@ interface PTClaimHandlerConfig {
     signatureDeadlineSeconds?: number;
     now?: () => number;
     /**
-     * Optional v1.6+ — when set, mints route through `MintFeeWrapper` so a
-     * fee is skimmed and split per the registered recipient list. Caller
-     * responsibility:
-     *   - DAO must have called `IssuerRegistry.setMintFeeWrapper(this address)`
-     *   - The PointToken must have been registered (cascaded from
-     *     `IssuerRegistry.addIssuer` or owner-only `wrapper.registerToken`)
-     * When unset, claims fall back to direct PointToken.mint (no fee skim).
+     * Optional override for the v1.6+ MintFeeWrapper address. By default the
+     * handler auto-resolves the wrapper from the request's `chainId` via
+     * `getContractAddresses(chainId).mintFeeWrapper`. Set this only when:
+     *   - testing against a non-canonical wrapper deploy, or
+     *   - the SDK's hardcoded address is stale and you can't bump the SDK yet
+     *
+     * Pass the dead-zero address to opt OUT of the wrapper path (force direct
+     * mint with no fee). Pass `undefined` (default) to use SDK's lookup.
+     *
+     * Caller responsibility either way:
+     *   - DAO must have called `IssuerRegistry.setMintFeeWrapper(...)` so
+     *     `addIssuer` cascades the recipient list.
+     *   - The PointToken must have been registered with the wrapper (via
+     *     `addIssuer` cascade or owner-only `wrapper.registerToken`).
      */
     mintFeeWrapperAddress?: Address;
 }
@@ -2543,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
@@ -2238,13 +2278,20 @@ interface PTClaimHandlerConfig {
     signatureDeadlineSeconds?: number;
     now?: () => number;
     /**
-     * Optional v1.6+ — when set, mints route through `MintFeeWrapper` so a
-     * fee is skimmed and split per the registered recipient list. Caller
-     * responsibility:
-     *   - DAO must have called `IssuerRegistry.setMintFeeWrapper(this address)`
-     *   - The PointToken must have been registered (cascaded from
-     *     `IssuerRegistry.addIssuer` or owner-only `wrapper.registerToken`)
-     * When unset, claims fall back to direct PointToken.mint (no fee skim).
+     * Optional override for the v1.6+ MintFeeWrapper address. By default the
+     * handler auto-resolves the wrapper from the request's `chainId` via
+     * `getContractAddresses(chainId).mintFeeWrapper`. Set this only when:
+     *   - testing against a non-canonical wrapper deploy, or
+     *   - the SDK's hardcoded address is stale and you can't bump the SDK yet
+     *
+     * Pass the dead-zero address to opt OUT of the wrapper path (force direct
+     * mint with no fee). Pass `undefined` (default) to use SDK's lookup.
+     *
+     * Caller responsibility either way:
+     *   - DAO must have called `IssuerRegistry.setMintFeeWrapper(...)` so
+     *     `addIssuer` cascades the recipient list.
+     *   - The PointToken must have been registered with the wrapper (via
+     *     `addIssuer` cascade or owner-only `wrapper.registerToken`).
      */
     mintFeeWrapperAddress?: Address;
 }
@@ -2543,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,6 +2431,11 @@ var PTClaimError = class extends 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 {
@@ -2416,9 +2472,11 @@ var PTClaimHandler = class {
         );
       }
     }
-    const { batchExecutor: batchExecutorAddress } = getContractAddresses3(
-      request.chainId
-    );
+    const chainAddresses = getContractAddresses3(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,
@@ -2447,7 +2505,7 @@ var PTClaimHandler = class {
           domain,
           mintRequestNonce: request.mintRequestNonce,
           deadline: signatureDeadline,
-          mintFeeWrapperAddress: this.cfg.mintFeeWrapperAddress
+          mintFeeWrapperAddress: resolvedWrapper
           // No feeAmount/feeRecipient — RelayService auto-resolves.
         });
       } catch (err) {
@@ -2470,7 +2528,7 @@ var PTClaimHandler = class {
             mintRequestNonce: request.mintRequestNonce,
             deadline: signatureDeadline,
             feeAmount: 0n,
-            mintFeeWrapperAddress: this.cfg.mintFeeWrapperAddress
+            mintFeeWrapperAddress: resolvedWrapper
           });
         } catch (err) {
           throw new PTClaimError(
@@ -4133,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 = {
@@ -4140,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;
     }
@@ -4414,7 +4478,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";
 export {
   AdapterMisconfiguredError,
   AuthError,