@pafi-dev/issuer 0.12.7 → 0.15.0

package/dist/index.js

@@ -779,8 +779,8 @@ var RelayService = class {
    * provides a pre-signed `BurnRequest` + sig bytes (typically from
    * `PTRedeemHandler`).
    *
-   * Direct burn (no sig) was dropped in v1.4 — every burn now goes
-   * through the issuer-signed `BurnRequest` path.
+   * Direct burn (no sig) is not used — every burn goes through the
+   * issuer-signed `BurnRequest` path.
    */
   async prepareBurn(params) {
     if (!params.pointTokenAddress) {
@@ -1064,7 +1064,7 @@ var PointIndexer = class {
   // Event fetching — two modes (wrapper vs direct)
   // -------------------------------------------------------------------------
   /**
-   * Wrapper mode (v1.6): listen for `MintWithFee` on the wrapper,
+   * Wrapper mode: 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.
    */
@@ -1349,7 +1349,6 @@ import {
   getMintFeeBps,
   getMintRequestNonce,
   getPointTokenBalance,
-  getReceiverConsentNonce,
   isMinter
 } from "@pafi-dev/core";
 var IssuerApiHandlers = class _IssuerApiHandlers {
@@ -1592,9 +1591,8 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
   /**
    * `GET /user?chainId=<id>&user=<addr>&pointToken=<addr>`
    *
-   * Returns per-user state the frontend needs to build a fresh
-   * `ReceiverConsent`: on-chain nonces + minter status + off-chain
-   * balance.
+   * Returns per-user state the frontend needs to build a fresh mint:
+   * on-chain nonces + minter status + off-chain balance.
    */
   async handleUser(userAddress, request) {
     if (request.chainId !== this.chainId) {
@@ -1621,16 +1619,14 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
         { requested: pointToken }
       );
     }
-    const [mintRequestNonce, receiverConsentNonce, offChainBalance, onChainBalance, minter] = await Promise.all([
+    const [mintRequestNonce, offChainBalance, onChainBalance, minter] = await Promise.all([
       getMintRequestNonce(this.provider, pointToken, normalizedAuthed),
-      getReceiverConsentNonce(this.provider, pointToken, normalizedAuthed),
       this.ledger.getBalance(normalizedAuthed, pointToken),
       getPointTokenBalance(this.provider, pointToken, normalizedAuthed),
       isMinter(this.provider, pointToken, normalizedAuthed)
     ]);
     return {
       mintRequestNonce,
-      receiverConsentNonce,
       offChainBalance,
       onChainBalance,
       totalBalance: offChainBalance + onChainBalance,
@@ -2209,38 +2205,42 @@ function mergePaymasterFields(userOp, paymasterFields) {
   }
   return merged;
 }
-async function prepareMobileUserOp(params) {
+function applyPaymasterGasEstimates(partialUserOp, paymasterFields, chainId) {
   const userOp = mergePaymasterFields(
-    params.partialUserOp,
-    params.paymasterFields
+    partialUserOp,
+    paymasterFields
   );
-  const userOpHash = computeUserOpHash(userOp, params.chainId);
-  const typedData = serializeUserOpTypedData(
-    buildUserOpTypedData(userOp, params.chainId)
+  return {
+    userOp,
+    userOpHash: computeUserOpHash(userOp, chainId),
+    typedData: serializeUserOpTypedData(buildUserOpTypedData(userOp, chainId))
+  };
+}
+async function prepareMobileUserOp(params) {
+  const sponsored = applyPaymasterGasEstimates(
+    params.partialUserOp,
+    params.paymasterFields,
+    params.chainId
   );
+  const { userOp, userOpHash } = sponsored;
   let fallback;
   let fallbackEntry;
   if (params.partialUserOpFallback) {
-    const fallbackUserOp = {
-      ...params.partialUserOpFallback,
-      maxFeePerGas: userOp.maxFeePerGas,
-      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
-    };
-    const fallbackHash = computeUserOpHash(fallbackUserOp, params.chainId);
-    const fallbackTypedData = serializeUserOpTypedData(
-      buildUserOpTypedData(fallbackUserOp, params.chainId)
+    fallback = applyPaymasterGasEstimates(
+      {
+        ...params.partialUserOpFallback,
+        maxFeePerGas: userOp.maxFeePerGas,
+        maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
+      },
+      void 0,
+      params.chainId
     );
-    fallback = {
-      userOp: fallbackUserOp,
-      userOpHash: fallbackHash,
-      typedData: fallbackTypedData
-    };
     fallbackEntry = {
-      callData: fallbackUserOp.callData,
-      callGasLimit: fallbackUserOp.callGasLimit.toString(),
-      verificationGasLimit: fallbackUserOp.verificationGasLimit.toString(),
-      preVerificationGas: fallbackUserOp.preVerificationGas.toString(),
-      userOpHash: fallbackHash
+      callData: fallback.userOp.callData,
+      callGasLimit: fallback.userOp.callGasLimit.toString(),
+      verificationGasLimit: fallback.userOp.verificationGasLimit.toString(),
+      preVerificationGas: fallback.userOp.preVerificationGas.toString(),
+      userOpHash: fallback.userOpHash
     };
   }
   const entry = {
@@ -2262,7 +2262,7 @@ async function prepareMobileUserOp(params) {
   };
   await params.store.save(params.lockId, entry, params.ttlSeconds);
   return {
-    sponsored: { userOp, userOpHash, typedData },
+    sponsored,
     fallback,
     entry
   };
@@ -2764,8 +2764,6 @@ import {
   ENTRY_POINT_V08 as ENTRY_POINT_V082,
   buildDelegationUserOp,
   buildEip7702Authorization,
-  computeUserOpHash as computeUserOpHash2,
-  buildUserOpTypedData as buildUserOpTypedData2,
   getContractAddresses as getContractAddresses5,
   serializeUserOpToJsonRpc as serializeUserOpToJsonRpc2
 } from "@pafi-dev/core";
@@ -2811,22 +2809,13 @@ async function handleDelegatePrepare(params) {
     eip7702Auth: authorization,
     onWarning: params.onWarning
   });
-  const merged = {
-    sender: userOp.sender,
-    nonce: userOp.nonce,
-    callData: userOp.callData,
-    callGasLimit: paymasterFields?.callGasLimit ?? userOp.callGasLimit,
-    verificationGasLimit: paymasterFields?.verificationGasLimit ?? userOp.verificationGasLimit,
-    preVerificationGas: paymasterFields?.preVerificationGas ?? userOp.preVerificationGas,
-    maxFeePerGas: paymasterFields?.maxFeePerGas ?? userOp.maxFeePerGas,
-    maxPriorityFeePerGas: paymasterFields?.maxPriorityFeePerGas ?? userOp.maxPriorityFeePerGas,
-    paymaster: paymasterFields?.paymaster,
-    paymasterVerificationGasLimit: paymasterFields?.paymasterVerificationGasLimit,
-    paymasterPostOpGasLimit: paymasterFields?.paymasterPostOpGasLimit,
-    paymasterData: paymasterFields?.paymasterData
-  };
-  const userOpHash = computeUserOpHash2(merged, params.chainId);
-  const typed = buildUserOpTypedData2(merged, params.chainId);
+  const prepared = applyPaymasterGasEstimates(
+    userOp,
+    paymasterFields,
+    params.chainId
+  );
+  const merged = prepared.userOp;
+  const userOpHash = prepared.userOpHash;
   await params.store.save(
     params.lockId,
     {
@@ -2855,7 +2844,7 @@ async function handleDelegatePrepare(params) {
   return {
     lockId: params.lockId,
     userOpHash,
-    typedData: serializeUserOpTypedData(typed),
+    typedData: prepared.typedData,
     expiresInSeconds: params.ttlSeconds,
     isSponsored: !!paymasterFields
   };
@@ -2966,7 +2955,6 @@ var IssuerApiAdapter = class {
     );
     return {
       mintRequestNonce: result.mintRequestNonce.toString(),
-      receiverConsentNonce: result.receiverConsentNonce.toString(),
       offChainBalance: result.offChainBalance.toString(),
       onChainBalance: result.onChainBalance.toString(),
       totalBalance: result.totalBalance.toString(),
@@ -3317,6 +3305,7 @@ var IssuerApiAdapter = class {
 import { isAddress } from "viem";
 import { PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
 var DEFAULT_CACHE_TTL_MS = 3e4;
+var MAX_REASONABLE_FEE_TIER = 1e6;
 var POOL_QUERY = `
   query GetPoolForPointToken($id: ID!) {
     pafiToken(id: $id) {
@@ -3324,8 +3313,6 @@ var POOL_QUERY = `
       pool {
         id
         feeTier
-        tickSpacing
-        hooks
         token0 { id }
         token1 { id }
       }
@@ -3350,12 +3337,20 @@ function createSubgraphPoolsProvider(config = {}) {
   const cacheTtl = config.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
   const fetchImpl = config.fetchImpl ?? globalThis.fetch;
   const now = config.now ?? (() => Date.now());
+  const onError = config.onError;
   const cache = /* @__PURE__ */ new Map();
   if (!fetchImpl) {
     throw new Error(
       "createSubgraphPoolsProvider: no fetch implementation available \u2014 pass `fetchImpl` or run on Node 18+"
     );
   }
+  const reportError = (err) => {
+    if (!onError) return;
+    try {
+      onError(err);
+    } catch {
+    }
+  };
   return async (request) => {
     const cacheKey = `${request.chainId}:${request.pointTokenAddress.toLowerCase()}`;
     if (cacheTtl > 0) {
@@ -3367,7 +3362,8 @@ function createSubgraphPoolsProvider(config = {}) {
     const pools = await fetchPoolsFromSubgraph(
       fetchImpl,
       subgraphUrl,
-      request.pointTokenAddress
+      request.pointTokenAddress,
+      reportError
     );
     if (cacheTtl > 0) {
       cache.set(cacheKey, {
@@ -3378,7 +3374,7 @@ function createSubgraphPoolsProvider(config = {}) {
     return { pools };
   };
 }
-async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress) {
+async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress, reportError) {
   let response;
   try {
     response = await fetchImpl(subgraphUrl, {
@@ -3390,24 +3386,38 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
       })
     });
   } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
     console.warn(
       "[subgraphPoolsProvider] subgraph unreachable:",
-      err.message
+      error.message
     );
+    reportError(error);
     return [];
   }
   if (!response.ok) {
-    console.warn(
-      `[subgraphPoolsProvider] subgraph returned ${response.status}`
+    const error = new Error(
+      `subgraph returned HTTP ${response.status}`
     );
+    console.warn(`[subgraphPoolsProvider] ${error.message}`);
+    reportError(error);
     return [];
   }
-  const json = await response.json();
-  if (json.errors && json.errors.length > 0) {
+  let json;
+  try {
+    json = await response.json();
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
     console.warn(
-      "[subgraphPoolsProvider] subgraph errors:",
-      json.errors.map((e) => e.message).join("; ")
+      "[subgraphPoolsProvider] subgraph returned non-JSON:",
+      error.message
     );
+    reportError(error);
+    return [];
+  }
+  if (json.errors && json.errors.length > 0) {
+    const msg = json.errors.map((e) => e.message).join("; ");
+    console.warn("[subgraphPoolsProvider] subgraph errors:", msg);
+    reportError(new Error(`subgraph GraphQL errors: ${msg}`));
     return [];
   }
   const token = json.data?.pafiToken;
@@ -3415,40 +3425,35 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
     return [];
   }
   const { pool } = token;
-  if (!isAddress(pool.hooks)) {
-    console.error(
-      "[PAFI] SubgraphPoolsProvider: invalid hooks address in response:",
-      pool.hooks,
-      "\u2014 skipping pool"
-    );
-    return [];
-  }
   if (!isAddress(pool.token0.id) || !isAddress(pool.token1.id)) {
-    console.error(
-      "[PAFI] SubgraphPoolsProvider: invalid token address in response \u2014 skipping pool"
+    const error = new Error(
+      "[PAFI] SubgraphPoolsProvider: invalid token address in response"
     );
+    console.error(error.message, "\u2014 skipping pool");
+    reportError(error);
     return [];
   }
-  if (!Number.isFinite(Number(pool.feeTier)) || !Number.isFinite(Number(pool.tickSpacing))) {
-    console.error(
-      "[PAFI] SubgraphPoolsProvider: invalid feeTier/tickSpacing \u2014 skipping pool"
+  const feeNum = Number(pool.feeTier);
+  if (!Number.isInteger(feeNum) || feeNum < 0 || feeNum >= MAX_REASONABLE_FEE_TIER) {
+    const error = new Error(
+      `[PAFI] SubgraphPoolsProvider: invalid feeTier value: ${pool.feeTier}`
     );
+    console.error(error.message, "\u2014 skipping pool");
+    reportError(error);
     return [];
   }
-  const [currency0, currency1] = sortCurrencies(
+  const [token0, token1] = sortTokens(
     pool.token0.id,
     pool.token1.id
   );
   const poolKey = {
-    currency0,
-    currency1,
-    fee: Number(pool.feeTier),
-    tickSpacing: Number(pool.tickSpacing),
-    hooks: pool.hooks
+    token0,
+    token1,
+    fee: feeNum
   };
   return [poolKey];
 }
-function sortCurrencies(a, b) {
+function sortTokens(a, b) {
   return a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a];
 }
 
@@ -3676,52 +3681,6 @@ function parseBigDecimalTo18(s) {
   return BigInt(whole + padded);
 }
 
-// src/balance/balanceAggregator.ts
-import { getPointTokenBalance as getPointTokenBalance3 } from "@pafi-dev/core";
-var BalanceAggregator = class {
-  provider;
-  ledger;
-  constructor(config) {
-    if (!config.provider) {
-      throw new Error("BalanceAggregator: provider is required");
-    }
-    if (!config.ledger) {
-      throw new Error("BalanceAggregator: ledger is required");
-    }
-    this.provider = config.provider;
-    this.ledger = config.ledger;
-  }
-  /**
-   * Combined balance for a single (user, token) pair. Fetches off-chain
-   * + on-chain in parallel.
-   */
-  async getCombinedBalance(user, pointToken) {
-    const [offChain, onChain] = await Promise.all([
-      this.ledger.getBalance(user, pointToken),
-      getPointTokenBalance3(this.provider, pointToken, user)
-    ]);
-    return {
-      offChain,
-      onChain,
-      total: offChain + onChain
-    };
-  }
-  /**
-   * Combined balance for multiple tokens owned by the same user. Runs
-   * all lookups in parallel. Returns a Map keyed by the token address
-   * (same casing as supplied — caller should normalize if needed).
-   */
-  async getCombinedBalanceMulti(user, pointTokens) {
-    const entries = await Promise.all(
-      pointTokens.map(async (token) => {
-        const balance = await this.getCombinedBalance(user, token);
-        return [token, balance];
-      })
-    );
-    return new Map(entries);
-  }
-};
-
 // src/pafi-backend/client.ts
 import { getPafiServiceUrls } from "@pafi-dev/core";
 function extractPafiErrorFields(json, status) {
@@ -4288,14 +4247,12 @@ function createIssuerService(config) {
     }
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
-  const firstIndexer = indexers.get(tokenAddresses[0]);
   const chainAddresses = getContractAddresses7(config.chainId);
   const resolvedContracts = {
     batchExecutor: chainAddresses.batchExecutor,
     usdt: chainAddresses.usdt,
     issuerRegistry: chainAddresses.issuerRegistry,
     mintingOracle: chainAddresses.mintingOracle,
-    pafiHook: chainAddresses.pafiHook,
     ...config.contracts
   };
   if (resolvedWrapperAddress !== void 0) {
@@ -4348,7 +4305,6 @@ function createIssuerService(config) {
     relay: relayService,
     fee: feeManager,
     indexers,
-    indexer: firstIndexer,
     api: handlers,
     redemption
   };
@@ -4561,12 +4517,11 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.12.7" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.15.0" : "dev";
 export {
   AdapterMisconfiguredError,
   AuthError,
   AuthService,
-  BalanceAggregator,
   BundlerNotConfiguredError,
   BundlerRejectedError,
   BurnIndexer,
@@ -4608,6 +4563,7 @@ export {
   SDK_ERROR_HTTP_STATUS_CODE,
   SettlementClient,
   ValidationError,
+  applyPaymasterGasEstimates,
   authenticateRequest,
   buildErrorEnvelope,
   buildSdkErrorBody,