@pafi-dev/issuer 0.3.0-alpha.0 → 0.3.0-beta.0

package/dist/index.js

@@ -582,11 +582,15 @@ var RelayError = class extends Error {
 };
 
 // src/relay/relayService.ts
+import { encodeFunctionData } from "viem";
 import {
   relayAbi,
   encodeMintAndSwap,
   simulateMintAndSwap as coreSimulateMintAndSwap,
-  SimulationError
+  SimulationError,
+  RELAYER_V2_ABI,
+  POINT_TOKEN_V2_ABI,
+  buildPartialUserOperation
 } from "@pafi-dev/core";
 var DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
 var RelayService = class {
@@ -712,6 +716,154 @@ var RelayService = class {
       );
     }
   }
+  // ==========================================================================
+  // v1.4 — Sponsored UserOp preparation (beta with mocked SC contracts)
+  // ==========================================================================
+  //
+  // These two methods build unsigned `PartialUserOperation` payloads for
+  // the Frontend to sign (via Privy) and submit to the Bundler. The
+  // Issuer Backend no longer broadcasts — that's the Frontend's job.
+  //
+  // Uses mocked Relayer v2 + PointToken ABIs from `@pafi-dev/core/contracts`.
+  // When SC delivers real ABIs, the imports swap but these method bodies
+  // stay the same (calldata encoder is ABI-driven).
+  // ==========================================================================
+  /**
+   * Build an unsigned UserOp for Scenario 1 (Mint).
+   *
+   * Flow:
+   *   1. Encode `Relayer.mint(request, userSig, issuerSig)` as the inner call
+   *   2. Optionally append a PT fee transfer from user → feeRecipient
+   *      (fee recovery happens on-chain via BatchExecutor, not via an
+   *      operator wallet)
+   *   3. Wrap all inner calls into `BatchExecutor.execute(calls[])`
+   *   4. Return a `PartialUserOperation` ready for:
+   *        - gas estimation (Bundler)
+   *        - paymaster sponsorship (PAFI Backend)
+   *        - user signature (Privy)
+   */
+  prepareMint(params) {
+    if (!params.relayerAddress) {
+      throw new RelayError("ENCODE_FAILED", "prepareMint: relayerAddress required");
+    }
+    if (!params.batchExecutorAddress) {
+      throw new RelayError(
+        "ENCODE_FAILED",
+        "prepareMint: batchExecutorAddress required"
+      );
+    }
+    if (!params.userAddress) {
+      throw new RelayError("ENCODE_FAILED", "prepareMint: userAddress required");
+    }
+    let mintCallData;
+    try {
+      mintCallData = encodeFunctionData({
+        abi: RELAYER_V2_ABI,
+        functionName: "mint",
+        args: [params.mintRequest, params.userSignature, params.issuerSignature]
+      });
+    } catch (err) {
+      throw new RelayError(
+        "ENCODE_FAILED",
+        `prepareMint: failed to encode Relayer.mint: ${errorMessage(err)}`,
+        err
+      );
+    }
+    const operations = [
+      {
+        target: params.relayerAddress,
+        value: 0n,
+        data: mintCallData
+      }
+    ];
+    if (params.mintRequest.feeAmount > 0n) {
+      operations.push({
+        target: params.pointTokenAddress,
+        value: 0n,
+        data: encodeFunctionData({
+          abi: POINT_TOKEN_V2_ABI,
+          functionName: "balanceOf",
+          // placeholder — real impl uses transfer
+          args: [params.mintRequest.feeRecipient]
+        })
+      });
+    }
+    return buildPartialUserOperation({
+      sender: params.userAddress,
+      nonce: params.aaNonce,
+      operations,
+      gasLimits: {
+        callGasLimit: params.callGasLimit ?? 500000n,
+        verificationGasLimit: params.verificationGasLimit ?? 150000n,
+        preVerificationGas: params.preVerificationGas ?? 50000n
+      }
+    });
+  }
+  /**
+   * Build an unsigned UserOp for Scenario 2 (Burn/Redeem).
+   *
+   * Two modes:
+   *   - `mode: 'burn'` — direct `PointToken.burn(amount)`; `msg.sender`
+   *     via EIP-7702 delegation is the user, so no signature needed
+   *     on-chain (the BurnConsent was already verified off-chain by
+   *     the issuer backend before we got here)
+   *   - `mode: 'burnWithSig'` — `PointToken.burnWithSig(consent, sig)`;
+   *     used when the issuer hasn't verified the consent and the
+   *     contract has to do it on-chain
+   */
+  prepareBurn(params) {
+    if (!params.pointTokenAddress) {
+      throw new RelayError("ENCODE_FAILED", "prepareBurn: pointTokenAddress required");
+    }
+    if (!params.batchExecutorAddress) {
+      throw new RelayError(
+        "ENCODE_FAILED",
+        "prepareBurn: batchExecutorAddress required"
+      );
+    }
+    let burnCallData;
+    try {
+      if (params.mode === "burnWithSig") {
+        if (!params.burnConsent || !params.consentSignature) {
+          throw new Error("burnWithSig requires burnConsent + consentSignature");
+        }
+        burnCallData = encodeFunctionData({
+          abi: POINT_TOKEN_V2_ABI,
+          functionName: "burnWithSig",
+          args: [params.burnConsent, params.consentSignature]
+        });
+      } else {
+        burnCallData = encodeFunctionData({
+          abi: POINT_TOKEN_V2_ABI,
+          functionName: "burn",
+          args: [params.amount]
+        });
+      }
+    } catch (err) {
+      throw new RelayError(
+        "ENCODE_FAILED",
+        `prepareBurn: failed to encode burn call: ${errorMessage(err)}`,
+        err
+      );
+    }
+    const operations = [
+      {
+        target: params.pointTokenAddress,
+        value: 0n,
+        data: burnCallData
+      }
+    ];
+    return buildPartialUserOperation({
+      sender: params.userAddress,
+      nonce: params.aaNonce,
+      operations,
+      gasLimits: {
+        callGasLimit: params.callGasLimit ?? 300000n,
+        verificationGasLimit: params.verificationGasLimit ?? 150000n,
+        preVerificationGas: params.preVerificationGas ?? 50000n
+      }
+    });
+  }
 };
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -1603,6 +1755,183 @@ var IssuerApiHandlers = class {
   }
 };
 
+// src/api/handlers/ptRedeemHandler.ts
+import { getAddress as getAddress7 } from "viem";
+import { verifyBurnConsent } from "@pafi-dev/core";
+var DEFAULT_REDEEM_LOCK_MS = 15 * 60 * 1e3;
+var PTRedeemError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PTRedeemError";
+  }
+  code;
+};
+var PTRedeemHandler = class {
+  ledger;
+  relayService;
+  pointTokenAddress;
+  batchExecutorAddress;
+  chainId;
+  domain;
+  redeemLockDurationMs;
+  now;
+  constructor(config) {
+    if (!config.ledger.reservePendingCredit) {
+      throw new PTRedeemError(
+        "LEDGER_NOT_SUPPORTED",
+        "PTRedeemHandler requires a ledger that implements reservePendingCredit() (v0.3.0+)"
+      );
+    }
+    this.ledger = config.ledger;
+    this.relayService = config.relayService;
+    this.pointTokenAddress = getAddress7(config.pointTokenAddress);
+    this.batchExecutorAddress = getAddress7(config.batchExecutorAddress);
+    this.chainId = config.chainId;
+    this.domain = config.domain;
+    this.redeemLockDurationMs = config.redeemLockDurationMs ?? DEFAULT_REDEEM_LOCK_MS;
+    this.now = config.now ?? (() => Date.now());
+  }
+  async handle(request) {
+    if (request.amount <= 0n) {
+      throw new PTRedeemError("INVALID_CONSENT", "redeem amount must be positive");
+    }
+    if (request.consent.amount !== request.amount) {
+      throw new PTRedeemError(
+        "AMOUNT_MISMATCH",
+        `consent.amount (${request.consent.amount}) must match request.amount (${request.amount})`
+      );
+    }
+    const nowSeconds = BigInt(Math.floor(this.now() / 1e3));
+    if (request.consent.deadline <= nowSeconds) {
+      throw new PTRedeemError(
+        "EXPIRED_CONSENT",
+        `consent deadline (${request.consent.deadline}) already passed`
+      );
+    }
+    const verification = await verifyBurnConsent(
+      {
+        name: this.domain.name,
+        chainId: this.chainId,
+        verifyingContract: this.domain.verifyingContract ?? this.pointTokenAddress
+      },
+      request.consent,
+      request.consentSignature,
+      request.userAddress
+    );
+    if (!verification.isValid) {
+      throw new PTRedeemError(
+        "SIGNATURE_MISMATCH",
+        `signer mismatch \u2014 expected ${request.userAddress}, got ${verification.recoveredAddress}`
+      );
+    }
+    const lockId = await this.ledger.reservePendingCredit(
+      request.userAddress,
+      request.amount,
+      this.redeemLockDurationMs,
+      this.pointTokenAddress
+    );
+    const userOp = this.relayService.prepareBurn({
+      mode: "burnWithSig",
+      userAddress: request.userAddress,
+      aaNonce: request.aaNonce,
+      pointTokenAddress: this.pointTokenAddress,
+      batchExecutorAddress: this.batchExecutorAddress,
+      burnConsent: request.consent,
+      consentSignature: parseSigStruct(request.consentSignature)
+    });
+    return {
+      lockId,
+      userOp,
+      expiresInSeconds: Math.floor(this.redeemLockDurationMs / 1e3)
+    };
+  }
+};
+function parseSigStruct(serialized) {
+  const raw = serialized.slice(2);
+  if (raw.length !== 130) {
+    throw new PTRedeemError(
+      "INVALID_CONSENT",
+      `signature must be 65 bytes, got ${raw.length / 2}`
+    );
+  }
+  const r = `0x${raw.slice(0, 64)}`;
+  const s = `0x${raw.slice(64, 128)}`;
+  const v = parseInt(raw.slice(128, 130), 16);
+  return { v, r, s };
+}
+
+// src/api/handlers/topUpRedemptionHandler.ts
+import { getAddress as getAddress8 } from "viem";
+import { getPointTokenBalance as getPointTokenBalance2 } from "@pafi-dev/core";
+var TopUpRedemptionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TopUpRedemptionError";
+  }
+  code;
+};
+var TopUpRedemptionHandler = class {
+  ledger;
+  ptRedeemHandler;
+  provider;
+  pointTokenAddress;
+  constructor(config) {
+    this.ledger = config.ledger;
+    this.ptRedeemHandler = config.ptRedeemHandler;
+    this.provider = config.provider;
+    this.pointTokenAddress = getAddress8(config.pointTokenAddress);
+  }
+  async handle(request) {
+    const offChainBalance = await this.ledger.getBalance(
+      request.userAddress,
+      this.pointTokenAddress
+    );
+    if (offChainBalance >= request.requiredAmount) {
+      return { action: "NO_TOP_UP_NEEDED", offChainBalance };
+    }
+    const shortfall = request.requiredAmount - offChainBalance;
+    const onChainBalance = await getPointTokenBalance2(
+      this.provider,
+      this.pointTokenAddress,
+      request.userAddress
+    );
+    if (onChainBalance < shortfall) {
+      return {
+        action: "INSUFFICIENT_ONCHAIN",
+        offChainBalance,
+        onChainBalance,
+        shortfall
+      };
+    }
+    if (request.redeemRequest.consent.amount < shortfall) {
+      throw new TopUpRedemptionError(
+        "CONSENT_AMOUNT_TOO_LOW",
+        `consent.amount (${request.redeemRequest.consent.amount}) must cover shortfall (${shortfall})`
+      );
+    }
+    if (request.redeemRequest.consent.amount !== shortfall) {
+      throw new TopUpRedemptionError(
+        "CONSENT_AMOUNT_TOO_LOW",
+        `consent.amount (${request.redeemRequest.consent.amount}) must equal shortfall (${shortfall}) exactly \u2014 re-sign with correct amount`
+      );
+    }
+    const redeem = await this.ptRedeemHandler.handle({
+      userAddress: request.userAddress,
+      amount: shortfall,
+      consent: request.redeemRequest.consent,
+      consentSignature: request.redeemRequest.consentSignature,
+      aaNonce: request.redeemRequest.aaNonce
+    });
+    return {
+      action: "TOP_UP_STARTED",
+      shortfall,
+      redeem
+    };
+  }
+};
+
 // src/pools/subgraphPoolsProvider.ts
 var DEFAULT_CACHE_TTL_MS = 3e4;
 var POOL_QUERY = `
@@ -1815,7 +2144,7 @@ function toUsdtPerNative(priceFloat, usdtDecimals) {
 }
 
 // src/balance/balanceAggregator.ts
-import { getPointTokenBalance as getPointTokenBalance2 } from "@pafi-dev/core";
+import { getPointTokenBalance as getPointTokenBalance3 } from "@pafi-dev/core";
 var BalanceAggregator = class {
   provider;
   ledger;
@@ -1836,7 +2165,7 @@ var BalanceAggregator = class {
   async getCombinedBalance(user, pointToken) {
     const [offChain, onChain] = await Promise.all([
       this.ledger.getBalance(user, pointToken),
-      getPointTokenBalance2(this.provider, pointToken, user)
+      getPointTokenBalance3(this.provider, pointToken, user)
     ]);
     return {
       offChain,
@@ -2081,7 +2410,7 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-import { getAddress as getAddress7 } from "viem";
+import { getAddress as getAddress9 } from "viem";
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -2107,7 +2436,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => getAddress7(a));
+  const tokenAddresses = rawAddresses.map((a) => getAddress9(a));
   const ledger = config.ledger ?? new MemoryPointLedger();
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -2224,12 +2553,16 @@ export {
   MintingGatewayError,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
+  PTRedeemError,
+  PTRedeemHandler,
   PafiBackendClient,
   PafiBackendError,
   PointIndexer,
   PrivateKeySigner,
   RelayError,
   RelayService,
+  TopUpRedemptionError,
+  TopUpRedemptionHandler,
   authenticateRequest,
   createIssuerService,
   createSubgraphNativeUsdtQuoter,