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

package/dist/index.cjs

@@ -34,12 +34,16 @@ __export(index_exports, {
   MintingGatewayError: () => MintingGatewayError,
   NonceManager: () => NonceManager,
   PAFI_ISSUER_SDK_VERSION: () => PAFI_ISSUER_SDK_VERSION,
+  PTRedeemError: () => PTRedeemError,
+  PTRedeemHandler: () => PTRedeemHandler,
   PafiBackendClient: () => PafiBackendClient,
   PafiBackendError: () => PafiBackendError,
   PointIndexer: () => PointIndexer,
   PrivateKeySigner: () => PrivateKeySigner,
   RelayError: () => RelayError,
   RelayService: () => RelayService,
+  TopUpRedemptionError: () => TopUpRedemptionError,
+  TopUpRedemptionHandler: () => TopUpRedemptionHandler,
   authenticateRequest: () => authenticateRequest,
   createIssuerService: () => createIssuerService,
   createSubgraphNativeUsdtQuoter: () => createSubgraphNativeUsdtQuoter,
@@ -630,6 +634,7 @@ var RelayError = class extends Error {
 };
 
 // src/relay/relayService.ts
+var import_viem5 = require("viem");
 var import_core3 = require("@pafi-dev/core");
 var DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
 var RelayService = class {
@@ -755,6 +760,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 = (0, import_viem5.encodeFunctionData)({
+        abi: import_core3.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: (0, import_viem5.encodeFunctionData)({
+          abi: import_core3.POINT_TOKEN_V2_ABI,
+          functionName: "balanceOf",
+          // placeholder — real impl uses transfer
+          args: [params.mintRequest.feeRecipient]
+        })
+      });
+    }
+    return (0, import_core3.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 = (0, import_viem5.encodeFunctionData)({
+          abi: import_core3.POINT_TOKEN_V2_ABI,
+          functionName: "burnWithSig",
+          args: [params.burnConsent, params.consentSignature]
+        });
+      } else {
+        burnCallData = (0, import_viem5.encodeFunctionData)({
+          abi: import_core3.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 (0, import_core3.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);
@@ -1055,8 +1208,8 @@ var InMemoryCursorStore = class {
 };
 
 // src/indexer/pointIndexer.ts
-var import_viem5 = require("viem");
-var TRANSFER_EVENT = (0, import_viem5.parseAbiItem)(
+var import_viem6 = require("viem");
+var TRANSFER_EVENT = (0, import_viem6.parseAbiItem)(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -1176,10 +1329,10 @@ var PointIndexer = class {
     for (const log of logs) {
       const args = log.args;
       if (!args.from || !args.to || args.value === void 0) continue;
-      if ((0, import_viem5.getAddress)(args.from) !== ZERO_ADDRESS) continue;
+      if ((0, import_viem6.getAddress)(args.from) !== ZERO_ADDRESS) continue;
       if (log.blockNumber === null || log.transactionHash === null) continue;
       out.push({
-        to: (0, import_viem5.getAddress)(args.to),
+        to: (0, import_viem6.getAddress)(args.to),
         amount: args.value,
         blockNumber: log.blockNumber,
         txHash: log.transactionHash,
@@ -1235,8 +1388,8 @@ function pickMatchingLock(locks, amount) {
 }
 
 // src/indexer/burnIndexer.ts
-var import_viem6 = require("viem");
-var TRANSFER_EVENT2 = (0, import_viem6.parseAbiItem)(
+var import_viem7 = require("viem");
+var TRANSFER_EVENT2 = (0, import_viem7.parseAbiItem)(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
 var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
@@ -1355,10 +1508,10 @@ var BurnIndexer = class {
     for (const log of logs) {
       const args = log.args;
       if (!args.from || !args.to || args.value === void 0) continue;
-      if ((0, import_viem6.getAddress)(args.to) !== ZERO_ADDRESS2) continue;
+      if ((0, import_viem7.getAddress)(args.to) !== ZERO_ADDRESS2) continue;
       if (log.blockNumber === null || log.transactionHash === null) continue;
       out.push({
-        from: (0, import_viem6.getAddress)(args.from),
+        from: (0, import_viem7.getAddress)(args.from),
         amount: args.value,
         blockNumber: log.blockNumber,
         txHash: log.transactionHash,
@@ -1386,7 +1539,7 @@ var BurnIndexer = class {
 };
 
 // src/api/handlers.ts
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 var import_core5 = require("@pafi-dev/core");
 var IssuerApiHandlers = class {
   authService;
@@ -1418,7 +1571,7 @@ var IssuerApiHandlers = class {
         "IssuerApiHandlers: pointTokenAddress or pointTokenAddresses required"
       );
     }
-    const normalized = raw.map((a) => (0, import_viem7.getAddress)(a));
+    const normalized = raw.map((a) => (0, import_viem8.getAddress)(a));
     this.supportedTokens = new Set(normalized);
     this.defaultToken = normalized[0];
     this.chainId = config.chainId;
@@ -1519,14 +1672,14 @@ var IssuerApiHandlers = class {
         `handleUser: unsupported chainId ${request.chainId}`
       );
     }
-    const normalizedAuthed = (0, import_viem7.getAddress)(userAddress);
-    const normalizedRequest = (0, import_viem7.getAddress)(request.userAddress);
+    const normalizedAuthed = (0, import_viem8.getAddress)(userAddress);
+    const normalizedRequest = (0, import_viem8.getAddress)(request.userAddress);
     if (normalizedAuthed !== normalizedRequest) {
       throw new Error(
         "handleUser: request userAddress must match authenticated user"
       );
     }
-    const pointToken = (0, import_viem7.getAddress)(request.pointTokenAddress);
+    const pointToken = (0, import_viem8.getAddress)(request.pointTokenAddress);
     if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleUser: unsupported pointToken ${pointToken}`
@@ -1569,7 +1722,7 @@ var IssuerApiHandlers = class {
         `handleBuildConsentTypedData: unsupported chainId ${request.chainId}`
       );
     }
-    const pointToken = (0, import_viem7.getAddress)(request.pointTokenAddress);
+    const pointToken = (0, import_viem8.getAddress)(request.pointTokenAddress);
     if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleBuildConsentTypedData: unsupported pointToken ${pointToken}`
@@ -1609,14 +1762,14 @@ var IssuerApiHandlers = class {
         `handleClaimAndSwap: unsupported chainId ${request.chainId}`
       );
     }
-    const pointToken = (0, import_viem7.getAddress)(request.pointTokenAddress);
+    const pointToken = (0, import_viem8.getAddress)(request.pointTokenAddress);
     if (!this.supportedTokens.has(pointToken)) {
       throw new Error(
         `handleClaimAndSwap: unsupported pointToken ${pointToken}`
       );
     }
     const result = await this.gateway.processMintAndCashOut({
-      userAddress: (0, import_viem7.getAddress)(userAddress),
+      userAddress: (0, import_viem8.getAddress)(userAddress),
       pointTokenAddress: pointToken,
       chainId: request.chainId,
       domain: request.domain,
@@ -1636,6 +1789,183 @@ var IssuerApiHandlers = class {
   }
 };
 
+// src/api/handlers/ptRedeemHandler.ts
+var import_viem9 = require("viem");
+var import_core6 = require("@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 = (0, import_viem9.getAddress)(config.pointTokenAddress);
+    this.batchExecutorAddress = (0, import_viem9.getAddress)(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 (0, import_core6.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
+var import_viem10 = require("viem");
+var import_core7 = require("@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 = (0, import_viem10.getAddress)(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 (0, import_core7.getPointTokenBalance)(
+      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 = `
@@ -1848,7 +2178,7 @@ function toUsdtPerNative(priceFloat, usdtDecimals) {
 }
 
 // src/balance/balanceAggregator.ts
-var import_core6 = require("@pafi-dev/core");
+var import_core8 = require("@pafi-dev/core");
 var BalanceAggregator = class {
   provider;
   ledger;
@@ -1869,7 +2199,7 @@ var BalanceAggregator = class {
   async getCombinedBalance(user, pointToken) {
     const [offChain, onChain] = await Promise.all([
       this.ledger.getBalance(user, pointToken),
-      (0, import_core6.getPointTokenBalance)(this.provider, pointToken, user)
+      (0, import_core8.getPointTokenBalance)(this.provider, pointToken, user)
     ]);
     return {
       offChain,
@@ -2114,7 +2444,7 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-var import_viem8 = require("viem");
+var import_viem11 = require("viem");
 function createIssuerService(config) {
   if (!config.provider) {
     throw new Error("createIssuerService: provider is required");
@@ -2140,7 +2470,7 @@ function createIssuerService(config) {
       "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
     );
   }
-  const tokenAddresses = rawAddresses.map((a) => (0, import_viem8.getAddress)(a));
+  const tokenAddresses = rawAddresses.map((a) => (0, import_viem11.getAddress)(a));
   const ledger = config.ledger ?? new MemoryPointLedger();
   const sessionStore = config.sessionStore ?? new MemorySessionStore();
   const policy = config.policy ?? new DefaultPolicyEngine({ ledger });
@@ -2258,12 +2588,16 @@ var PAFI_ISSUER_SDK_VERSION = "0.1.0";
   MintingGatewayError,
   NonceManager,
   PAFI_ISSUER_SDK_VERSION,
+  PTRedeemError,
+  PTRedeemHandler,
   PafiBackendClient,
   PafiBackendError,
   PointIndexer,
   PrivateKeySigner,
   RelayError,
   RelayService,
+  TopUpRedemptionError,
+  TopUpRedemptionHandler,
   authenticateRequest,
   createIssuerService,
   createSubgraphNativeUsdtQuoter,