@pafi-dev/issuer 0.18.0 → 0.20.0

package/dist/index.js

@@ -865,21 +865,21 @@ var RelayService = class {
   // =========================================================================
   // Preview methods — produce bundler-ready partial UserOps WITHOUT signing.
   //
-  // These exist so callers can compute an accurate gas estimate via
-  // `bundlerClient.estimateUserOperationGas(...)` BEFORE committing to a
-  // signed MintRequest / BurnRequest (signing is HSM-backed and expensive
-  // in prod). The returned `callData` matches the SHAPE of the real call;
-  // the EIP-712 signature bytes are placeholder. Bundler simulation
-  // doesn't validate the signature, so the gas units come back accurate.
+  // These exist so callers can fetch an accurate gas estimate from PAFI's
+  // `/v1/estimate-gas-fee` BEFORE committing to a signed MintRequest /
+  // BurnRequest (HSM/KMS signing is expensive in production). The
+  // returned `callData` matches the SHAPE of the real call; the EIP-712
+  // signature bytes are a placeholder. Bundler simulation doesn't
+  // validate the signature, so the gas estimate comes back accurate.
   //
-  // Cache-wise: same SC version + same scenario → same calldata shape →
-  // same bundler-returned gas units. The first call seeds the cache; the
-  // rest hit it.
+  // Cache-wise: same SC version + same scenario produce identical
+  // calldata shape → identical bundler-returned gas units. The first
+  // call seeds the cache; subsequent ones hit it.
   // =========================================================================
   /**
    * Build a dummy `PartialUserOperation` for the mint scenario, suitable
    * for `feeManager.estimateGasFee({ partialUserOp, ... })`. NO signing —
-   * uses a 65-byte zero signature in place of the real minter sig.
+   * uses a 65-byte zero signature placeholder.
    */
   previewMintUserOp(params) {
     const useWrapper = params.mintFeeWrapperAddress !== void 0;
@@ -916,7 +916,11 @@ var RelayService = class {
       nonce: params.aaNonce,
       operations: [{ target: mintTarget, value: 0n, data: mintCallData }],
       // Gas limits ignored by bundler estimate — it computes them.
-      gasLimits: { callGasLimit: 1n, verificationGasLimit: 1n, preVerificationGas: 1n }
+      gasLimits: {
+        callGasLimit: 1n,
+        verificationGasLimit: 1n,
+        preVerificationGas: 1n
+      }
     });
   }
   /** Burn-side mirror of `previewMintUserOp`. */
@@ -937,7 +941,11 @@ var RelayService = class {
       operations: [
         { target: params.pointTokenAddress, value: 0n, data: burnCallData }
       ],
-      gasLimits: { callGasLimit: 1n, verificationGasLimit: 1n, preVerificationGas: 1n }
+      gasLimits: {
+        callGasLimit: 1n,
+        verificationGasLimit: 1n,
+        preVerificationGas: 1n
+      }
     });
   }
 };
@@ -946,85 +954,21 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/relay/gasUnitsCache.ts
-import { keccak256 } from "viem";
-var DEFAULT_TTL_MS = 5 * 6e4;
-var DEFAULT_CODEHASH_TTL_MS = 60 * 6e4;
-var DEFAULT_MAX_ENTRIES = 100;
-var GasUnitsCache = class {
-  entries = /* @__PURE__ */ new Map();
-  codehashEntries = /* @__PURE__ */ new Map();
-  ttlMs;
-  codehashTtlMs;
-  maxEntries;
-  constructor(config = {}) {
-    this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;
-    this.codehashTtlMs = config.codehashTtlMs ?? DEFAULT_CODEHASH_TTL_MS;
-    this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  }
-  async buildKey(params) {
-    const codehash = await this.getCodehash(
-      params.provider,
-      params.contractAddress
-    );
-    const pm = params.paymasterAddress?.toLowerCase() ?? "0x0";
-    return `${params.scenario}:${codehash}:${pm}`;
-  }
-  get(key, now = Date.now()) {
-    const entry = this.entries.get(key);
-    if (!entry) return null;
-    if (entry.expiresAt <= now) {
-      this.entries.delete(key);
-      return null;
-    }
-    return entry.gasUnits;
-  }
-  set(key, gasUnits, now = Date.now()) {
-    if (this.entries.size >= this.maxEntries && !this.entries.has(key)) {
-      const eldest = this.entries.keys().next().value;
-      if (eldest !== void 0) this.entries.delete(eldest);
-    }
-    this.entries.set(key, { gasUnits, expiresAt: now + this.ttlMs });
-  }
-  invalidate() {
-    this.entries.clear();
-    this.codehashEntries.clear();
-  }
-  size() {
-    return this.entries.size;
-  }
-  async getCodehash(provider, address) {
-    const lower = address.toLowerCase();
-    const now = Date.now();
-    const cached = this.codehashEntries.get(lower);
-    if (cached && cached.expiresAt > now) return cached.codehash;
-    const code = await provider.getCode({ address });
-    const codehash = code ? keccak256(code) : "0x0";
-    this.codehashEntries.set(lower, {
-      codehash,
-      expiresAt: now + this.codehashTtlMs
-    });
-    return codehash;
-  }
-};
-
 // src/relay/feeManager.ts
 var DEFAULT_GAS_UNITS = 500000n;
 var DEFAULT_PREMIUM_BPS = 1e4;
-var DEFAULT_PAYMASTER_OVERHEAD = 80000n;
-var DUMMY_SIGNATURE = "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c";
 var FeeManager = class _FeeManager {
   provider;
-  gasUnits;
+  fallbackGasUnits;
   gasPremiumBps;
   quoteNativeToFee;
   bundlerClient;
-  cache;
-  paymasterOverheadGas;
   metrics;
-  // Short-lived in-flight fee cache (legacy behavior). Distinct from
-  // `cache` — that one stores gasUnits per scenario; this one stores the
-  // FULL computed fee value, valid for 10s to absorb burst calls.
+  // Short-lived fee-value cache. Distinct from the estimator's cache:
+  // this absorbs burst calls (e.g. 5 user requests in 5s all hit the
+  // /gas-fee endpoint) by remembering the COMPUTED PT amount, not the
+  // gas units. Only used by the no-opts legacy path; estimator path
+  // gets its caching from the PAFI side instead.
   cachedFee = null;
   cacheExpiresAt = 0;
   static FEE_CACHE_TTL_MS = 1e4;
@@ -1033,29 +977,26 @@ var FeeManager = class _FeeManager {
     if (!config.quoteNativeToFee)
       throw new Error("FeeManager: quoteNativeToFee required");
     this.provider = config.provider;
-    this.gasUnits = config.gasUnits ?? DEFAULT_GAS_UNITS;
+    this.fallbackGasUnits = config.gasUnits ?? DEFAULT_GAS_UNITS;
     this.gasPremiumBps = config.gasPremiumBps ?? DEFAULT_PREMIUM_BPS;
     this.quoteNativeToFee = config.quoteNativeToFee;
     this.bundlerClient = config.bundlerClient;
-    this.cache = new GasUnitsCache(config.cache);
-    this.paymasterOverheadGas = config.paymasterOverheadGas ?? DEFAULT_PAYMASTER_OVERHEAD;
     this.metrics = config.metrics;
   }
   /**
-   * Estimate the fee (in the caller's fee currency) to charge for the
-   * next sponsored UserOp.
+   * Estimate the operator fee for the next sponsored UserOp.
    *
-   *   gasUnits      = bundler-estimated (cached) or hardcoded fallback
-   *   nativeCost    = gasUnits × gasPrice
-   *   withPremium   = nativeCost × premiumBps / 10_000
-   *   fee           = quoteNativeToFee(withPremium)
+   * Without `opts` → legacy path: `gasUnits × gasPrice × premium →
+   * quoteNativeToFee`. Cached for 10 s to absorb bursts.
    *
-   * When `opts.partialUserOp` is omitted, behaves exactly like v0.16.x:
-   * uses the hardcoded `gasUnits` default.
+   * With `opts` AND `bundlerClient` → estimator path. Each call may
+   * hit a different bundler-cached result; the SDK does NOT add its
+   * own value cache because the estimator's cache TTL is the source
+   * of truth for "how long is this estimate good for".
    */
   async estimateGasFee(opts = {}) {
-    const now = Date.now();
     const isLegacyCall = !opts.partialUserOp && !opts.scenario && !opts.contractAddress;
+    const now = Date.now();
     if (isLegacyCall && this.cachedFee !== null && now < this.cacheExpiresAt) {
       return this.cachedFee;
     }
@@ -1080,49 +1021,32 @@ var FeeManager = class _FeeManager {
     }
     return fee;
   }
-  /**
-   * Manually purge the per-scenario gas-units cache. Useful after an SC
-   * upgrade when ops wants the next estimate to refresh immediately
-   * (the codehash check would catch it on the NEXT call anyway, but
-   * this forces it now).
-   */
+  /** Manually purge the legacy 10s fee cache. */
   invalidateCache() {
-    this.cache.invalidate();
     this.cachedFee = null;
     this.cacheExpiresAt = 0;
   }
   async resolveGasUnits(opts) {
     if (!this.bundlerClient || !opts.partialUserOp || !opts.scenario || !opts.contractAddress) {
-      return { gasUnits: this.gasUnits, source: "fallback" };
+      return { gasUnits: this.fallbackGasUnits, source: "fallback" };
     }
     try {
-      const cacheKey = await this.cache.buildKey({
+      const result = await this.bundlerClient.getGasUnits({
         scenario: opts.scenario,
         contractAddress: opts.contractAddress,
         paymasterAddress: opts.paymasterAddress,
-        provider: this.provider
+        partialUserOp: opts.partialUserOp
       });
-      const cached = this.cache.get(cacheKey);
-      if (cached !== null) {
-        return { gasUnits: cached, source: "cache" };
-      }
-      const estimate = await this.bundlerClient.estimateUserOperationGas({
-        sender: opts.partialUserOp.sender,
-        nonce: opts.partialUserOp.nonce,
-        callData: opts.partialUserOp.callData,
-        signature: opts.partialUserOp.signature ?? DUMMY_SIGNATURE
-        // Intentionally NO paymaster fields — avoids chicken-and-egg
-        // (paymasterData depends on gasLimits). Overhead added below.
-      });
-      const gasUnits = estimate.callGasLimit + estimate.verificationGasLimit + estimate.preVerificationGas + (estimate.paymasterVerificationGasLimit ?? 0n) + (estimate.paymasterPostOpGasLimit ?? 0n) + this.paymasterOverheadGas;
-      this.cache.set(cacheKey, gasUnits);
-      return { gasUnits, source: "bundler" };
+      return { gasUnits: result.gasUnits, source: "estimator" };
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       this.safeEmit(
-        () => this.metrics?.onBundlerError?.({ scenario: opts.scenario, reason })
+        () => this.metrics?.onEstimatorError?.({
+          scenario: opts.scenario,
+          reason
+        })
       );
-      return { gasUnits: this.gasUnits, source: "fallback" };
+      return { gasUnits: this.fallbackGasUnits, source: "fallback" };
     }
   }
   safeEmit(fn) {
@@ -1133,6 +1057,70 @@ var FeeManager = class _FeeManager {
   }
 };
 
+// src/relay/bundlerEstimator.ts
+var PafiEstimatorHttpError = class extends Error {
+  status;
+  body;
+  constructor(status, body, message) {
+    super(message ?? `PAFI estimator HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+  }
+};
+function createPafiEstimatorClient(config) {
+  const { baseUrl, apiKey, issuerId } = config;
+  if (!baseUrl) throw new Error("createPafiEstimatorClient: baseUrl required");
+  if (!apiKey) throw new Error("createPafiEstimatorClient: apiKey required");
+  if (!issuerId) throw new Error("createPafiEstimatorClient: issuerId required");
+  const fetchImpl = config.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "createPafiEstimatorClient: no fetch implementation available \u2014 pass `fetchImpl`"
+    );
+  }
+  const url = `${baseUrl.replace(/\/$/, "")}/v1/estimate-gas-fee`;
+  return {
+    async getGasUnits(input) {
+      const body = JSON.stringify({
+        partialUserOp: {
+          sender: input.partialUserOp.sender,
+          // Hex-encode bigint for JSON safety. Sponsor-relayer parses
+          // back to bigint at the DTO layer.
+          nonce: `0x${input.partialUserOp.nonce.toString(16)}`,
+          callData: input.partialUserOp.callData,
+          signature: input.partialUserOp.signature
+        },
+        scenario: input.scenario,
+        contractAddress: input.contractAddress,
+        paymasterAddress: input.paymasterAddress
+      });
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${apiKey}`,
+          "x-issuer-id": issuerId
+        },
+        body
+      });
+      if (!res.ok) {
+        let errBody = null;
+        try {
+          errBody = await res.json();
+        } catch {
+        }
+        throw new PafiEstimatorHttpError(res.status, errBody);
+      }
+      const json = await res.json();
+      return {
+        gasUnits: BigInt(json.gasUnits),
+        source: json.source,
+        expiresAt: json.expiresAt
+      };
+    }
+  };
+}
+
 // src/indexer/types.ts
 var InMemoryCursorStore = class {
   cursor;
@@ -4768,7 +4756,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.18.0" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.20.0" : "dev";
 export {
   AdapterMisconfiguredError,
   AuthError,
@@ -4780,7 +4768,6 @@ export {
   DEFAULT_REDEMPTION_POLICY,
   DefaultPolicyEngine,
   FeeManager,
-  GasUnitsCache,
   InMemoryCursorStore,
   IssuerApiAdapter,
   IssuerApiHandlers,
@@ -4801,6 +4788,7 @@ export {
   PTRedeemHandler,
   PafiBackendClient,
   PafiBackendError,
+  PafiEstimatorHttpError,
   PafiSdkError,
   PendingUserOpForbiddenError,
   PendingUserOpNotFoundError,
@@ -4821,6 +4809,7 @@ export {
   buildSdkErrorBody,
   createIssuerService,
   createNativePtQuoter,
+  createPafiEstimatorClient,
   createSdkErrorMapper,
   createSubgraphNativeUsdtQuoter,
   createSubgraphPoolsProvider,