@pafi-dev/issuer 0.5.40 → 0.5.42

package/dist/index.js

@@ -2593,6 +2593,427 @@ function createSdkErrorMapper(factories) {
   };
 }
 
+// src/api/issuerApiAdapter.ts
+import { getAddress as getAddress10 } from "viem";
+import {
+  buildAndSignSponsorAuth,
+  computeAuthorizationHash,
+  decodeBatchExecuteCalls as decodeBatchExecuteCalls4,
+  encodeBatchExecute as encodeBatchExecute2,
+  ENTRY_POINT_V08 as ENTRY_POINT_V083,
+  getContractAddresses as getContractAddresses8,
+  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress2
+} from "@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: getAddress10(pointTokenAddress) }
+    );
+    return { pools: result.pools };
+  }
+  async user(authenticatedAddress, chainId, userAddress, pointTokenAddress) {
+    const result = await this.cfg.issuerService.api.handleUser(
+      authenticatedAddress,
+      {
+        chainId,
+        userAddress: getAddress10(userAddress),
+        pointTokenAddress: getAddress10(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: getAddress10(pointTokenAddress)
+      })
+    ]);
+    const quote = await quotePointTokenToUsdt({
+      provider: this.cfg.provider,
+      chainId,
+      pointTokenAddress: getAddress10(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 = getAddress10(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: decodeBatchExecuteCalls4(response.userOp.callData),
+      callsFallback: response.fallback ? decodeBatchExecuteCalls4(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: getAddress10(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 = getAddress10(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 = getAddress10(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 } = getContractAddresses8(chainId);
+    const code = await this.cfg.provider.getCode({
+      address: authenticatedAddress
+    });
+    return {
+      isDelegated: parseEip7702DelegatedAddress2(code) !== null,
+      batchExecutorAddress: batchExecutor
+    };
+  }
+  async delegatePrepare(authenticatedAddress, chainId) {
+    const { batchExecutor } = getContractAddresses8(chainId);
+    const accountNonce = BigInt(
+      await this.cfg.provider.getTransactionCount({
+        address: authenticatedAddress
+      })
+    );
+    const authorizationHash = 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 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
 import { isAddress } from "viem";
 import { PAFI_SUBGRAPH_URL } from "@pafi-dev/core";
@@ -3211,8 +3632,8 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-import { getAddress as getAddress10 } from "viem";
-import { getContractAddresses as getContractAddresses8 } from "@pafi-dev/core";
+import { getAddress as getAddress11 } from "viem";
+import { getContractAddresses as getContractAddresses9 } from "@pafi-dev/core";
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -3232,7 +3653,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => getAddress10(a));
+  const tokenAddresses = rawAddresses.map((a) => getAddress11(a));
   const ledger = config.ledger;
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -3282,7 +3703,7 @@ function createIssuerService(config) {
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
   const firstIndexer = indexers.get(tokenAddresses[0]);
-  const chainAddresses = getContractAddresses8(config.chainId);
+  const chainAddresses = getContractAddresses9(config.chainId);
   const resolvedContracts = {
     batchExecutor: chainAddresses.batchExecutor,
     usdt: chainAddresses.usdt,
@@ -3330,11 +3751,11 @@ function createIssuerService(config) {
 }
 
 // src/issuer-state/validator.ts
-import { getAddress as getAddress11 } from "viem";
+import { getAddress as getAddress12 } from "viem";
 import {
   POINT_TOKEN_V2_ABI as POINT_TOKEN_V2_ABI3,
   issuerRegistryGetIssuerFlatAbi,
-  getContractAddresses as getContractAddresses9
+  getContractAddresses as getContractAddresses10
 } from "@pafi-dev/core";
 var ISSUER_RECORD_TTL_MS = 3e4;
 var IssuerStateValidator = class _IssuerStateValidator {
@@ -3352,7 +3773,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * `CONTRACT_ADDRESSES` map for the given chain.
    */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = getContractAddresses9(chainId);
+    const { issuerRegistry } = getContractAddresses10(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
@@ -3361,7 +3782,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    */
   invalidate(pointToken) {
     if (pointToken) {
-      const key = getAddress11(pointToken);
+      const key = getAddress12(pointToken);
       this.pointTokenIssuerCache.delete(key);
       this.stateCache.delete(key);
       this.inflight.delete(key);
@@ -3376,7 +3797,7 @@ var IssuerStateValidator = class _IssuerStateValidator {
    * The issuer field is set at `initialize()` and never changes.
    */
   async getIssuerAddressForPointToken(pointToken) {
-    const key = getAddress11(pointToken);
+    const key = getAddress12(pointToken);
     const cached = this.pointTokenIssuerCache.get(key);
     if (cached) return cached;
     const issuer = await this.provider.readContract({
@@ -3384,15 +3805,15 @@ var IssuerStateValidator = class _IssuerStateValidator {
       abi: POINT_TOKEN_V2_ABI3,
       functionName: "issuer"
     });
-    this.pointTokenIssuerCache.set(key, getAddress11(issuer));
-    return getAddress11(issuer);
+    this.pointTokenIssuerCache.set(key, getAddress12(issuer));
+    return getAddress12(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 = getAddress11(pointToken);
+    const tokenAddr = getAddress12(pointToken);
     const now = Date.now();
     const cached = this.stateCache.get(tokenAddr);
     if (cached && cached.expiresAt > now) return cached.value;
@@ -3501,6 +3922,7 @@ export {
   DefaultPolicyEngine,
   FeeManager,
   InMemoryCursorStore,
+  IssuerApiAdapter,
   IssuerApiHandlers,
   IssuerStateError,
   IssuerStateValidator,