@pafi-dev/issuer 0.5.40 → 0.5.42

package/dist/index.cjs

@@ -29,6 +29,7 @@ __export(index_exports, {
   DefaultPolicyEngine: () => DefaultPolicyEngine,
   FeeManager: () => FeeManager,
   InMemoryCursorStore: () => InMemoryCursorStore,
+  IssuerApiAdapter: () => IssuerApiAdapter,
   IssuerApiHandlers: () => IssuerApiHandlers,
   IssuerStateError: () => IssuerStateError,
   IssuerStateValidator: () => IssuerStateValidator,
@@ -36,7 +37,7 @@ __export(index_exports, {
   MemorySessionStore: () => MemorySessionStore,
   NonceManager: () => NonceManager,
   PAFI_ISSUER_SDK_VERSION: () => PAFI_ISSUER_SDK_VERSION,
-  PAFI_SUBGRAPH_URL: () => import_core14.PAFI_SUBGRAPH_URL,
+  PAFI_SUBGRAPH_URL: () => import_core15.PAFI_SUBGRAPH_URL,
   PTClaimError: () => PTClaimError,
   PTClaimHandler: () => PTClaimHandler,
   PTRedeemError: () => PTRedeemError,
@@ -2618,9 +2619,422 @@ function createSdkErrorMapper(factories) {
   };
 }
 
-// src/pools/subgraphPoolsProvider.ts
+// src/api/issuerApiAdapter.ts
 var import_viem11 = require("viem");
 var import_core14 = require("@pafi-dev/core");
+var IssuerApiAdapter = class {
+  cfg;
+  constructor(config) {
+    this.cfg = config;
+  }
+  // ------------------------------ Read endpoints ---------------------------
+  async config(chainId) {
+    const result = await this.cfg.issuerService.api.handleConfig(chainId);
+    return {
+      chainId: result.chainId,
+      contracts: result.contracts
+    };
+  }
+  async gasFee() {
+    const result = await this.cfg.issuerService.api.handleGasFee();
+    return { gasFeeUsdt: result.gasFeeUsdt.toString() };
+  }
+  async pools(authenticatedAddress, chainId, pointTokenAddress) {
+    const result = await this.cfg.issuerService.api.handlePools(
+      authenticatedAddress,
+      { chainId, pointTokenAddress: (0, import_viem11.getAddress)(pointTokenAddress) }
+    );
+    return { pools: result.pools };
+  }
+  async user(authenticatedAddress, chainId, userAddress, pointTokenAddress) {
+    const result = await this.cfg.issuerService.api.handleUser(
+      authenticatedAddress,
+      {
+        chainId,
+        userAddress: (0, import_viem11.getAddress)(userAddress),
+        pointTokenAddress: (0, import_viem11.getAddress)(pointTokenAddress)
+      }
+    );
+    return {
+      mintRequestNonce: result.mintRequestNonce.toString(),
+      receiverConsentNonce: result.receiverConsentNonce.toString(),
+      offChainBalance: result.offChainBalance.toString(),
+      onChainBalance: result.onChainBalance.toString(),
+      totalBalance: result.totalBalance.toString(),
+      balance: result.offChainBalance.toString(),
+      isMinter: result.isMinter
+    };
+  }
+  async quote(authenticatedAddress, chainId, pointTokenAddress, pointAmount) {
+    const [gasFeeResult, poolsResult] = await Promise.all([
+      this.cfg.issuerService.api.handleGasFee(),
+      this.cfg.issuerService.api.handlePools(authenticatedAddress, {
+        chainId,
+        pointTokenAddress: (0, import_viem11.getAddress)(pointTokenAddress)
+      })
+    ]);
+    const quote = await quotePointTokenToUsdt({
+      provider: this.cfg.provider,
+      chainId,
+      pointTokenAddress: (0, import_viem11.getAddress)(pointTokenAddress),
+      pointAmount,
+      pools: poolsResult.pools,
+      gasFeeUsdt: gasFeeResult.gasFeeUsdt
+    });
+    const dto = {
+      pointAmount: pointAmount.toString(),
+      estimatedUsdtOut: quote.estimatedUsdtOut.toString(),
+      gasFeeUsdt: gasFeeResult.gasFeeUsdt.toString(),
+      netUsdtOut: quote.netUsdtOut.toString(),
+      exchangeRate: quote.exchangeRate,
+      suggestedDeadline: quote.suggestedDeadline.toString(),
+      gasEstimate: quote.gasEstimate.toString()
+    };
+    if (quote.quoteError) dto.quoteError = quote.quoteError;
+    return dto;
+  }
+  // ------------------------------ Action endpoints -------------------------
+  async claim(input) {
+    const ptClaimHandler = this.assertHandler(
+      this.cfg.ptClaimHandler,
+      "ptClaimHandler",
+      "claim"
+    );
+    const pointTokenAddress = (0, import_viem11.getAddress)(input.pointTokenAddress);
+    const result = await ptClaimHandler.handle({
+      authenticatedAddress: input.authenticatedAddress,
+      userAddress: input.authenticatedAddress,
+      amount: input.amount,
+      pointTokenAddress,
+      chainId: input.chainId,
+      aaNonce: input.aaNonce,
+      mintRequestNonce: input.mintRequestNonce
+    });
+    const sponsorAuth = await this.buildSponsorAuth(
+      input.authenticatedAddress,
+      result.userOp.callData,
+      input.chainId,
+      "mint"
+    );
+    return {
+      calls: result.calls,
+      callsFallback: result.callsFallback,
+      feeAmount: result.feeAmount.toString(),
+      lockId: result.lockId,
+      signatureDeadline: result.signatureDeadline.toString(),
+      sponsorAuth
+    };
+  }
+  async redeem(input) {
+    this.assertRedeemHandler();
+    const response = await this.cfg.ptRedeemHandler.handle({
+      userAddress: input.authenticatedAddress,
+      authenticatedAddress: input.authenticatedAddress,
+      amount: input.amount,
+      aaNonce: input.aaNonce,
+      chainId: input.chainId
+    });
+    const sponsorAuth = await this.buildSponsorAuth(
+      input.authenticatedAddress,
+      response.userOp.callData,
+      input.chainId,
+      "burn"
+    );
+    return {
+      calls: (0, import_core14.decodeBatchExecuteCalls)(response.userOp.callData),
+      callsFallback: response.fallback ? (0, import_core14.decodeBatchExecuteCalls)(response.fallback.userOp.callData) : void 0,
+      feeAmount: response.feeAmount.toString(),
+      lockId: response.lockId,
+      lockIdFallback: response.fallback?.lockId,
+      netCreditAmount: response.netCreditAmount.toString(),
+      netCreditAmountFallback: response.fallback?.netCreditAmount.toString(),
+      expiresInSeconds: response.expiresInSeconds,
+      signatureDeadline: response.signatureDeadline.toString(),
+      sponsorAuth
+    };
+  }
+  async swap(input) {
+    const swapHandler = this.assertHandler(
+      this.cfg.swapHandler,
+      "swapHandler",
+      "swap"
+    );
+    const result = await swapHandler.handle({
+      userAddress: input.authenticatedAddress,
+      chainId: input.chainId,
+      pointTokenAddress: (0, import_viem11.getAddress)(input.pointTokenAddress),
+      amountIn: input.amountIn,
+      aaNonce: input.aaNonce,
+      slippageBps: input.slippageBps
+    });
+    const sponsorAuth = await this.buildSponsorAuth(
+      input.authenticatedAddress,
+      result.userOp.callData,
+      input.chainId,
+      "swap"
+    );
+    return {
+      calls: result.calls,
+      callsFallback: result.callsFallback,
+      feeAmount: result.feeAmount.toString(),
+      estimatedUsdtOut: result.estimatedUsdtOut.toString(),
+      minAmountOut: result.minAmountOut.toString(),
+      estimatedUsdtOutFallback: result.estimatedUsdtOutFallback?.toString(),
+      minAmountOutFallback: result.minAmountOutFallback?.toString(),
+      deadline: result.deadline.toString(),
+      sponsorAuth
+    };
+  }
+  async perpDeposit(input) {
+    const perpHandler = this.assertHandler(
+      this.cfg.perpHandler,
+      "perpHandler",
+      "perpDeposit"
+    );
+    const result = await perpHandler.handle({
+      userAddress: input.authenticatedAddress,
+      chainId: input.chainId,
+      amount: input.amount,
+      brokerId: input.brokerId,
+      aaNonce: input.aaNonce
+    });
+    const sponsorAuth = await this.buildSponsorAuth(
+      input.authenticatedAddress,
+      result.userOp.callData,
+      input.chainId,
+      "perp-deposit"
+    );
+    return {
+      calls: result.calls,
+      callsFallback: result.callsFallback,
+      relayTokenFee: result.relayTokenFee.toString(),
+      maxFee: result.maxFee.toString(),
+      netDeposit: result.netDeposit.toString(),
+      ptGasFee: result.feeAmount.toString(),
+      accountId: result.accountId,
+      brokerHash: result.brokerHash,
+      usdcAddress: result.usdcAddress,
+      relayAddress: result.relayAddress,
+      sponsorAuth
+    };
+  }
+  // ------------------------------ Mobile endpoints -------------------------
+  async claimPrepare(input) {
+    const ptClaimHandler = this.assertHandler(
+      this.cfg.ptClaimHandler,
+      "ptClaimHandler",
+      "claimPrepare"
+    );
+    const pointTokenAddress = (0, import_viem11.getAddress)(input.pointTokenAddress);
+    const claimResult = await ptClaimHandler.handle({
+      authenticatedAddress: input.authenticatedAddress,
+      userAddress: input.authenticatedAddress,
+      amount: input.amount,
+      pointTokenAddress,
+      chainId: input.chainId,
+      aaNonce: input.aaNonce,
+      mintRequestNonce: input.mintRequestNonce
+    });
+    const prepared = await this.runMobilePrepare(
+      input.authenticatedAddress,
+      input.chainId,
+      claimResult.lockId,
+      claimResult.userOp,
+      claimResult.fallback,
+      "mint",
+      pointTokenAddress,
+      claimResult.expiresInSeconds
+    );
+    return {
+      lockId: claimResult.lockId,
+      userOpHash: prepared.sponsored.userOpHash,
+      typedData: prepared.sponsored.typedData,
+      userOpHashFallback: prepared.fallback?.userOpHash,
+      typedDataFallback: prepared.fallback?.typedData,
+      feeAmount: claimResult.feeAmount.toString(),
+      signatureDeadline: claimResult.signatureDeadline.toString(),
+      expiresInSeconds: claimResult.expiresInSeconds,
+      sponsored: prepared.isSponsored,
+      needsDelegation: prepared.needsDelegation
+    };
+  }
+  async claimSubmit(input) {
+    return await handleMobileSubmit({
+      lockId: input.lockId,
+      authenticatedAddress: input.authenticatedAddress,
+      signature: input.signature,
+      variant: input.variant,
+      store: this.cfg.pendingUserOpStore,
+      bindUserOpHash: (lockId, hash) => this.cfg.ledger.bindMintUserOpHash(lockId, hash),
+      pafiBackendClient: this.cfg.pafiBackendClient
+    });
+  }
+  async redeemPrepare(input) {
+    this.assertRedeemHandler();
+    const pointTokenAddress = (0, import_viem11.getAddress)(input.pointTokenAddress);
+    const redeemResponse = await this.cfg.ptRedeemHandler.handle({
+      userAddress: input.authenticatedAddress,
+      authenticatedAddress: input.authenticatedAddress,
+      amount: input.amount,
+      aaNonce: input.aaNonce,
+      chainId: input.chainId
+    });
+    const prepared = await this.runMobilePrepare(
+      input.authenticatedAddress,
+      input.chainId,
+      redeemResponse.lockId,
+      redeemResponse.userOp,
+      redeemResponse.fallback?.userOp,
+      "burn",
+      pointTokenAddress,
+      redeemResponse.expiresInSeconds
+    );
+    return {
+      lockId: redeemResponse.lockId,
+      userOpHash: prepared.sponsored.userOpHash,
+      typedData: prepared.sponsored.typedData,
+      userOpHashFallback: prepared.fallback?.userOpHash,
+      typedDataFallback: prepared.fallback?.typedData,
+      netCreditAmount: redeemResponse.netCreditAmount.toString(),
+      netCreditAmountFallback: redeemResponse.fallback?.netCreditAmount.toString(),
+      feeAmount: redeemResponse.feeAmount.toString(),
+      signatureDeadline: redeemResponse.signatureDeadline.toString(),
+      expiresInSeconds: redeemResponse.expiresInSeconds,
+      sponsored: prepared.isSponsored,
+      needsDelegation: prepared.needsDelegation
+    };
+  }
+  async redeemSubmit(input) {
+    return await handleMobileSubmit({
+      lockId: input.lockId,
+      authenticatedAddress: input.authenticatedAddress,
+      signature: input.signature,
+      variant: input.variant,
+      store: this.cfg.pendingUserOpStore,
+      bindUserOpHash: (lockId, hash) => this.cfg.ledger.bindCreditUserOpHash(lockId, hash),
+      pafiBackendClient: this.cfg.pafiBackendClient
+    });
+  }
+  async claimStatus(authenticatedAddress, lockId) {
+    return await handleClaimStatus({
+      lockId,
+      userAddress: authenticatedAddress,
+      ledger: this.cfg.ledger,
+      pafiBackendClient: this.cfg.pafiBackendClient,
+      onWarning: this.cfg.onWarning
+    });
+  }
+  async redeemStatus(authenticatedAddress, lockId) {
+    return await handleRedeemStatus({
+      lockId,
+      userAddress: authenticatedAddress,
+      ledger: this.cfg.ledger,
+      pafiBackendClient: this.cfg.pafiBackendClient,
+      onWarning: this.cfg.onWarning
+    });
+  }
+  // ------------------------------ Delegate endpoints -----------------------
+  async delegateStatus(authenticatedAddress, chainId) {
+    const { batchExecutor } = (0, import_core14.getContractAddresses)(chainId);
+    const code = await this.cfg.provider.getCode({
+      address: authenticatedAddress
+    });
+    return {
+      isDelegated: (0, import_core14.parseEip7702DelegatedAddress)(code) !== null,
+      batchExecutorAddress: batchExecutor
+    };
+  }
+  async delegatePrepare(authenticatedAddress, chainId) {
+    const { batchExecutor } = (0, import_core14.getContractAddresses)(chainId);
+    const accountNonce = BigInt(
+      await this.cfg.provider.getTransactionCount({
+        address: authenticatedAddress
+      })
+    );
+    const authorizationHash = (0, import_core14.computeAuthorizationHash)(
+      chainId,
+      batchExecutor,
+      accountNonce
+    );
+    return {
+      authorizationHash,
+      delegationNonce: accountNonce.toString(),
+      batchExecutorAddress: batchExecutor,
+      chainId
+    };
+  }
+  async delegateSubmit(input) {
+    const fees = await this.cfg.provider.estimateFeesPerGas();
+    const result = await handleDelegateSubmit({
+      userAddress: input.authenticatedAddress,
+      chainId: input.chainId,
+      delegationNonce: input.delegationNonce,
+      aaNonce: input.aaNonce,
+      authSig: input.authSig,
+      fees,
+      pafiBackendClient: this.cfg.pafiBackendClient,
+      onWarning: this.cfg.onWarning
+    });
+    return { userOpHash: result.userOpHash };
+  }
+  // ------------------------------ Internal helpers -------------------------
+  /**
+   * Build + sign a SponsorAuth payload. Returns `undefined` when no
+   * issuer id is configured, so the controller can skip the field.
+   */
+  async buildSponsorAuth(authenticatedAddress, callData, chainId, scenario) {
+    if (!this.cfg.pafiIssuerId) return void 0;
+    return (0, import_core14.buildAndSignSponsorAuth)({
+      userAddress: authenticatedAddress,
+      callData,
+      chainId,
+      scenario,
+      issuerId: this.cfg.pafiIssuerId,
+      issuerSignerWallet: this.cfg.issuerSignerWallet
+    });
+  }
+  async runMobilePrepare(authenticatedAddress, chainId, lockId, partialUserOp, partialUserOpFallback, scenario, pointTokenAddress, ttlSeconds) {
+    return await handleMobilePrepare({
+      userAddress: authenticatedAddress,
+      chainId,
+      lockId,
+      partialUserOp,
+      partialUserOpFallback,
+      scenario,
+      pointTokenAddress,
+      ttlSeconds,
+      store: this.cfg.pendingUserOpStore,
+      provider: this.cfg.provider,
+      pafiBackendClient: this.cfg.pafiBackendClient,
+      onWarning: this.cfg.onWarning
+    });
+  }
+  assertRedeemHandler() {
+    if (!this.cfg.ptRedeemHandler) {
+      throw new Error(
+        "PTRedeemHandler not wired \u2014 IssuerApiAdapter.redeem* require a configured ptRedeemHandler."
+      );
+    }
+  }
+  /**
+   * Narrow an optional handler to non-null and throw a clear error when
+   * the issuer wired the adapter without it. Lets issuers opt out of
+   * flows they don't expose (gg56 ships only mobile claim/redeem, so
+   * `swapHandler` + `perpHandler` aren't constructed).
+   */
+  assertHandler(handler, fieldName, methodName) {
+    if (handler === null || handler === void 0) {
+      throw new Error(
+        `${fieldName} not wired \u2014 IssuerApiAdapter.${methodName}() requires a configured ${fieldName}.`
+      );
+    }
+    return handler;
+  }
+};
+
+// src/pools/subgraphPoolsProvider.ts
+var import_viem12 = require("viem");
+var import_core15 = require("@pafi-dev/core");
 var DEFAULT_CACHE_TTL_MS = 3e4;
 var POOL_QUERY = `
   query GetPoolForPointToken($id: ID!) {
@@ -2638,7 +3052,7 @@ var POOL_QUERY = `
   }
 `;
 function createSubgraphPoolsProvider(config = {}) {
-  const subgraphUrl = config.subgraphUrl ?? import_core14.PAFI_SUBGRAPH_URL;
+  const subgraphUrl = config.subgraphUrl ?? import_core15.PAFI_SUBGRAPH_URL;
   try {
     const parsed = new URL(subgraphUrl);
     if (process.env.NODE_ENV === "production" && parsed.protocol !== "https:") {
@@ -2720,7 +3134,7 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
     return [];
   }
   const { pool } = token;
-  if (!(0, import_viem11.isAddress)(pool.hooks)) {
+  if (!(0, import_viem12.isAddress)(pool.hooks)) {
     console.error(
       "[PAFI] SubgraphPoolsProvider: invalid hooks address in response:",
       pool.hooks,
@@ -2728,7 +3142,7 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress)
     );
     return [];
   }
-  if (!(0, import_viem11.isAddress)(pool.token0.id) || !(0, import_viem11.isAddress)(pool.token1.id)) {
+  if (!(0, import_viem12.isAddress)(pool.token0.id) || !(0, import_viem12.isAddress)(pool.token1.id)) {
     console.error(
       "[PAFI] SubgraphPoolsProvider: invalid token address in response \u2014 skipping pool"
     );
@@ -2770,7 +3184,7 @@ var PRICE_QUERY = `
   }
 `;
 function createSubgraphNativeUsdtQuoter(config = {}) {
-  const subgraphUrl = config.subgraphUrl ?? import_core14.PAFI_SUBGRAPH_URL;
+  const subgraphUrl = config.subgraphUrl ?? import_core15.PAFI_SUBGRAPH_URL;
   try {
     const parsed = new URL(subgraphUrl);
     if (process.env.NODE_ENV === "production" && parsed.protocol !== "https:") {
@@ -2878,8 +3292,8 @@ function toUsdtPerNative(priceFloat, usdtDecimals) {
 }
 
 // src/pools/nativePtQuoter.ts
-var import_viem12 = require("viem");
-var CHAINLINK_ABI = (0, import_viem12.parseAbi)([
+var import_viem13 = require("viem");
+var CHAINLINK_ABI = (0, import_viem13.parseAbi)([
   "function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)"
 ]);
 var CHAINLINK_MAX_AGE_S = 3600n;
@@ -2900,7 +3314,7 @@ function createNativePtQuoter(config) {
     provider,
     pointTokenAddress,
     chainlinkFeedAddress = "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
-    subgraphUrl = import_core14.PAFI_SUBGRAPH_URL,
+    subgraphUrl = import_core15.PAFI_SUBGRAPH_URL,
     cacheTtlMs = 3e4,
     fallbackEthPriceUsd = 3e3,
     fallbackPtPriceUsdt = 0.1,
@@ -2982,7 +3396,7 @@ function parseBigDecimalTo18(s) {
 }
 
 // src/balance/balanceAggregator.ts
-var import_core15 = require("@pafi-dev/core");
+var import_core16 = require("@pafi-dev/core");
 var BalanceAggregator = class {
   provider;
   ledger;
@@ -3003,7 +3417,7 @@ var BalanceAggregator = class {
   async getCombinedBalance(user, pointToken) {
     const [offChain, onChain] = await Promise.all([
       this.ledger.getBalance(user, pointToken),
-      (0, import_core15.getPointTokenBalance)(this.provider, pointToken, user)
+      (0, import_core16.getPointTokenBalance)(this.provider, pointToken, user)
     ]);
     return {
       offChain,
@@ -3236,8 +3650,8 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-var import_viem13 = require("viem");
-var import_core16 = require("@pafi-dev/core");
+var import_viem14 = require("viem");
+var import_core17 = require("@pafi-dev/core");
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -3257,7 +3671,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => (0, import_viem13.getAddress)(a));
+  const tokenAddresses = rawAddresses.map((a) => (0, import_viem14.getAddress)(a));
   const ledger = config.ledger;
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -3307,7 +3721,7 @@ function createIssuerService(config) {
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
   const firstIndexer = indexers.get(tokenAddresses[0]);
-  const chainAddresses = (0, import_core16.getContractAddresses)(config.chainId);
+  const chainAddresses = (0, import_core17.getContractAddresses)(config.chainId);
   const resolvedContracts = {
     batchExecutor: chainAddresses.batchExecutor,
     usdt: chainAddresses.usdt,
@@ -3355,8 +3769,8 @@ function createIssuerService(config) {
 }
 
 // src/issuer-state/validator.ts
-var import_viem14 = require("viem");
-var import_core17 = require("@pafi-dev/core");
+var import_viem15 = require("viem");
+var import_core18 = require("@pafi-dev/core");
 var ISSUER_RECORD_TTL_MS = 3e4;
 var IssuerStateValidator = class _IssuerStateValidator {
   constructor(provider, registryAddress) {
@@ -3373,7 +3787,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * `CONTRACT_ADDRESSES` map for the given chain.
    */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = (0, import_core17.getContractAddresses)(chainId);
+    const { issuerRegistry } = (0, import_core18.getContractAddresses)(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
@@ -3382,7 +3796,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    */
   invalidate(pointToken) {
     if (pointToken) {
-      const key = (0, import_viem14.getAddress)(pointToken);
+      const key = (0, import_viem15.getAddress)(pointToken);
       this.pointTokenIssuerCache.delete(key);
       this.stateCache.delete(key);
       this.inflight.delete(key);
@@ -3397,23 +3811,23 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * The issuer field is set at `initialize()` and never changes.
    */
   async getIssuerAddressForPointToken(pointToken) {
-    const key = (0, import_viem14.getAddress)(pointToken);
+    const key = (0, import_viem15.getAddress)(pointToken);
     const cached = this.pointTokenIssuerCache.get(key);
     if (cached) return cached;
     const issuer = await this.provider.readContract({
       address: key,
-      abi: import_core17.POINT_TOKEN_V2_ABI,
+      abi: import_core18.POINT_TOKEN_V2_ABI,
       functionName: "issuer"
     });
-    this.pointTokenIssuerCache.set(key, (0, import_viem14.getAddress)(issuer));
-    return (0, import_viem14.getAddress)(issuer);
+    this.pointTokenIssuerCache.set(key, (0, import_viem15.getAddress)(issuer));
+    return (0, import_viem15.getAddress)(issuer);
   }
   /**
    * Read registry record + totalSupply, with 30s cache and in-flight
    * deduplication. Does NOT throw on inactive/missing — returns raw state.
    */
   async getIssuerState(pointToken) {
-    const tokenAddr = (0, import_viem14.getAddress)(pointToken);
+    const tokenAddr = (0, import_viem15.getAddress)(pointToken);
     const now = Date.now();
     const cached = this.stateCache.get(tokenAddr);
     if (cached && cached.expiresAt > now) return cached.value;
@@ -3483,13 +3897,13 @@ var IssuerStateValidator = class _IssuerStateValidator {
     const [issuerTuple, totalSupply] = await Promise.all([
       this.provider.readContract({
         address: this.registryAddress,
-        abi: import_core17.issuerRegistryGetIssuerFlatAbi,
+        abi: import_core18.issuerRegistryGetIssuerFlatAbi,
         functionName: "getIssuer",
         args: [issuerAddr]
       }),
       this.provider.readContract({
         address: tokenAddr,
-        abi: import_core17.POINT_TOKEN_V2_ABI,
+        abi: import_core18.POINT_TOKEN_V2_ABI,
         functionName: "totalSupply"
       })
     ]);
@@ -3523,6 +3937,7 @@ var PAFI_ISSUER_SDK_VERSION = "0.4.0";
   DefaultPolicyEngine,
   FeeManager,
   InMemoryCursorStore,
+  IssuerApiAdapter,
   IssuerApiHandlers,
   IssuerStateError,
   IssuerStateValidator,