@pafi-dev/issuer 0.5.30 → 0.5.32

package/README.md

@@ -17,10 +17,10 @@ ledger, policy engine, EIP-712 issuer signing, relay submission, and mint/burn e
 - TypeScript >= 5.0
 - `viem` ^2.0.0 and `@pafi-dev/core` ^0.5.16 (peer dependencies)
 
-> **Latest:** `0.5.28` — adds bundler-receipt fallback for status polling
-> and propagates Pimlico's re-estimated gas + bundler-required gas price
-> through `SponsorshipResponse`. Required to fix `AA34` paymaster-sig
-> errors and the "status stuck PENDING" indexer race. See
+> **Latest:** `0.5.31` — `RelayService.prepareMint` / `prepareBurn`
+> now auto-quote the operator fee and auto-resolve the PAFI fee
+> recipient. Drop `feeAmount` / `feeRecipient` from your call sites;
+> SDK reads gas price + Chainlink + V4 subgraph internally. See
 > [Changelog](#changelog).
 
 ---
@@ -386,6 +386,43 @@ try {
 
 ## Changelog
 
+### 0.5.31
+
+`RelayService.prepareMint` / `prepareBurn` now auto-quote the operator
+fee + auto-resolve the PAFI fee recipient when the service is
+constructed with `provider + chainId`. `createIssuerService` wires
+this automatically — issuer integrations don't need to change
+anything to pick it up.
+
+**API changes** (additive, backwards-compatible):
+
+- `RelayService` constructor accepts an optional `RelayServiceConfig`
+  with `provider` + `chainId`. When set, callers can drop `feeAmount`
+  / `feeRecipient` from `prepareMint` / `prepareBurn` calls — the
+  service runs `quoteOperatorFeePt` (Chainlink ETH/USD + V4 subgraph
+  PT/USDT spot price) internally and pulls the canonical recipient
+  from `getContractAddresses(chainId).pafiFeeRecipient`.
+- `prepareBurn` is now `async` (was sync) — the auto-quote requires
+  RPC + subgraph reads. Callers must `await`. `PTRedeemHandler`
+  already does this.
+- `feeAmount: 0n` explicit means "no fee transfer" (force unsponsored
+  fallback variant). `undefined` means "auto-quote".
+- Existing callers that pass `feeAmount + feeRecipient` keep working
+  — those values override the auto-resolve.
+
+**Migration**: in your controller, drop the manual fee fetch when
+calling `relayService.prepareMint`:
+
+```diff
+- const { pafiFeeRecipient: feeRecipient } = getContractAddresses(chainId);
+- const feeAmount = await issuerService.fee.estimateGasFee();
+  const userOp = await relayService.prepareMint({
+    ...,
+-   feeAmount,
+-   feeRecipient,
+  });
+```
+
 ### 0.5.28
 
 `PafiBackendClient.getUserOpReceipt(userOpHash)` added.

package/dist/index.cjs

@@ -438,6 +438,43 @@ var RelayError = class extends Error {
 var import_viem3 = require("viem");
 var import_core2 = require("@pafi-dev/core");
 var RelayService = class {
+  provider;
+  chainId;
+  constructor(config = {}) {
+    this.provider = config.provider;
+    this.chainId = config.chainId;
+  }
+  /**
+   * Resolve the fee recipient + amount applied to the next UserOp:
+   *
+   *  - If caller passed an explicit `feeRecipient`, use it (testing
+   *    only — sponsor-relayer's L1 will reject any non-canonical
+   *    recipient with `INSUFFICIENT_FEE`). Otherwise, default to
+   *    `getContractAddresses(chainId).pafiFeeRecipient` when the
+   *    service has a `chainId` configured.
+   *  - If caller passed `feeAmount`, use it. Otherwise, when the
+   *    service has both `provider` + `chainId`, auto-quote via
+   *    `quoteOperatorFeePt`.
+   *  - When the service is unconfigured AND caller passed nothing,
+   *    return `{ feeAmount: 0n, feeRecipient: undefined }` — legacy
+   *    "no fee" behavior, caller must opt in for the gas-reimbursement
+   *    transfer to be added to the batch.
+   */
+  async resolveFee(params) {
+    const feeRecipient = params.feeRecipient ?? (this.chainId !== void 0 ? (0, import_core2.getContractAddresses)(this.chainId).pafiFeeRecipient : void 0);
+    if (params.feeAmount !== void 0) {
+      return { feeAmount: params.feeAmount, feeRecipient };
+    }
+    if (this.provider && this.chainId !== void 0) {
+      const feeAmount = await (0, import_core2.quoteOperatorFeePt)({
+        provider: this.provider,
+        chainId: this.chainId,
+        pointTokenAddress: params.pointTokenAddress
+      });
+      return { feeAmount, feeRecipient };
+    }
+    return { feeAmount: 0n, feeRecipient };
+  }
   /**
    * Build an unsigned UserOp for Scenario 1 (Mint) — sig-gated
    * `PointToken.mint(to, amount, deadline, minterSig)`.
@@ -522,14 +559,19 @@ var RelayService = class {
         data: mintCallData
       }
     ];
-    if (params.feeAmount && params.feeAmount > 0n) {
-      if (!params.feeRecipient) {
+    const { feeAmount, feeRecipient } = await this.resolveFee({
+      feeAmount: params.feeAmount,
+      feeRecipient: params.feeRecipient,
+      pointTokenAddress: params.pointTokenAddress
+    });
+    if (feeAmount > 0n) {
+      if (!feeRecipient) {
         throw new RelayError(
           "ENCODE_FAILED",
-          "prepareMint: feeRecipient required when feeAmount > 0"
+          "prepareMint: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`."
         );
       }
-      if (params.feeRecipient === "0x0000000000000000000000000000000000000000") {
+      if (feeRecipient === "0x0000000000000000000000000000000000000000") {
         throw new RelayError(
           "ENCODE_FAILED",
           "prepareMint: feeRecipient must not be zero address"
@@ -541,7 +583,7 @@ var RelayService = class {
         data: (0, import_viem3.encodeFunctionData)({
           abi: import_viem3.erc20Abi,
           functionName: "transfer",
-          args: [params.feeRecipient, params.feeAmount]
+          args: [feeRecipient, feeAmount]
         })
       });
     }
@@ -567,7 +609,7 @@ var RelayService = class {
    *     burnerSig)`. Caller provides a pre-signed `BurnRequest` + sig
    *     bytes (typically from `PTRedeemHandler`).
    */
-  prepareBurn(params) {
+  async prepareBurn(params) {
     if (!params.pointTokenAddress) {
       throw new RelayError("ENCODE_FAILED", "prepareBurn: pointTokenAddress required");
     }
@@ -608,14 +650,19 @@ var RelayService = class {
       );
     }
     const operations = [];
-    if (params.feeAmount && params.feeAmount > 0n) {
-      if (!params.feeRecipient) {
+    const { feeAmount, feeRecipient } = await this.resolveFee({
+      feeAmount: params.feeAmount,
+      feeRecipient: params.feeRecipient,
+      pointTokenAddress: params.pointTokenAddress
+    });
+    if (feeAmount > 0n) {
+      if (!feeRecipient) {
         throw new RelayError(
           "ENCODE_FAILED",
-          "prepareBurn: feeRecipient required when feeAmount > 0"
+          "prepareBurn: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`."
         );
       }
-      if (params.feeRecipient === "0x0000000000000000000000000000000000000000") {
+      if (feeRecipient === "0x0000000000000000000000000000000000000000") {
         throw new RelayError(
           "ENCODE_FAILED",
           "prepareBurn: feeRecipient must not be zero address"
@@ -627,7 +674,7 @@ var RelayService = class {
         data: (0, import_viem3.encodeFunctionData)({
           abi: import_viem3.erc20Abi,
           functionName: "transfer",
-          args: [params.feeRecipient, params.feeAmount]
+          args: [feeRecipient, feeAmount]
         })
       });
     }
@@ -1461,7 +1508,7 @@ var PTRedeemHandler = class {
       this.redeemLockDurationMs,
       this.pointTokenAddress
     );
-    const sponsoredUserOp = this.relayService.prepareBurn({
+    const sponsoredUserOp = await this.relayService.prepareBurn({
       mode: "burnWithSig",
       userAddress: request.userAddress,
       aaNonce: request.aaNonce,
@@ -1495,15 +1542,19 @@ var PTRedeemHandler = class {
         this.redeemLockDurationMs,
         this.pointTokenAddress
       );
-      const fallbackUserOp = this.relayService.prepareBurn({
+      const fallbackUserOp = await this.relayService.prepareBurn({
         mode: "burnWithSig",
         userAddress: request.userAddress,
         aaNonce: request.aaNonce,
         pointTokenAddress: this.pointTokenAddress,
         batchExecutorAddress: this.batchExecutorAddress,
         burnRequest: fallbackBurnRequest,
-        burnerSignature: fallbackSig
-        // No feeAmount/feeRecipient — fallback is fee-free.
+        burnerSignature: fallbackSig,
+        // Explicit 0n — fallback is fee-free regardless of how
+        // RelayService is configured. Without this, an
+        // auto-quoting RelayService would try to quote a fee here
+        // and re-add the PT.transfer we're trying to strip.
+        feeAmount: 0n
       });
       fallback = {
         lockId: fallbackLockId,
@@ -2239,7 +2290,10 @@ function createIssuerService(config) {
     authServiceConfig.jwtExpiresIn = config.auth.jwtExpiresIn;
   }
   const authService = new AuthService(authServiceConfig);
-  const relayService = new RelayService();
+  const relayService = new RelayService({
+    provider: config.provider,
+    chainId: config.chainId
+  });
   let feeManager;
   if (config.fee) {
     feeManager = new FeeManager({