@pafi-dev/issuer 0.39.2 → 0.40.0

package/dist/index.js

@@ -11,11 +11,16 @@ import {
   payloadFromGenericError,
   payloadFromHttpException,
   payloadFromPafiSdkError
-} from "./chunk-QLNGNH4A.js";
-import "./chunk-BRKEJJFQ.js";
+} from "./chunk-RNQQYJIB.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
 
 // src/policy/defaultPolicy.ts
 var DefaultPolicyEngine = class {
+  static {
+    __name(this, "DefaultPolicyEngine");
+  }
   ledger;
   provider;
   mintingOracleAddress;
@@ -31,20 +36,18 @@ var DefaultPolicyEngine = class {
     if (opts.resolveIssuer) this.resolveIssuer = opts.resolveIssuer;
     if (!opts.mintingOracleAddress || !opts.provider || !opts.verifyMintCap || !opts.resolveIssuer) {
       if (process.env.NODE_ENV === "production") {
-        throw new Error(
-          "[PAFI] DefaultPolicyEngine: on-chain MintingOracle cap check is required in production. Configure mintingOracleAddress, provider, verifyMintCap, and resolveIssuer."
-        );
+        throw new Error("[PAFI] DefaultPolicyEngine: on-chain MintingOracle cap check is required in production. Configure mintingOracleAddress, provider, verifyMintCap, and resolveIssuer.");
       }
     }
   }
   async evaluate(request) {
     if (request.amount <= 0n) {
-      return { approved: false, reason: "Amount must be positive" };
+      return {
+        approved: false,
+        reason: "Amount must be positive"
+      };
     }
-    const available = await this.ledger.getBalance(
-      request.userAddress,
-      request.pointTokenAddress
-    );
+    const available = await this.ledger.getBalance(request.userAddress, request.pointTokenAddress);
     if (available < request.amount) {
       return {
         approved: false,
@@ -54,12 +57,7 @@ var DefaultPolicyEngine = class {
     if (this.mintingOracleAddress && this.provider && this.verifyMintCap && this.resolveIssuer) {
       try {
         const issuer = await this.resolveIssuer(request.pointTokenAddress);
-        await this.verifyMintCap(
-          this.provider,
-          this.mintingOracleAddress,
-          issuer,
-          request.amount
-        );
+        await this.verifyMintCap(this.provider, this.mintingOracleAddress, issuer, request.amount);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
@@ -68,7 +66,9 @@ var DefaultPolicyEngine = class {
         };
       }
     }
-    return { approved: true };
+    return {
+      approved: true
+    };
   }
 };
 
@@ -77,17 +77,16 @@ import { randomBytes } from "crypto";
 import { getAddress } from "viem";
 var DEFAULT_NONCE_TTL_MS = 5 * 60 * 1e3;
 var MemorySessionStore = class {
+  static {
+    __name(this, "MemorySessionStore");
+  }
   nonces = /* @__PURE__ */ new Map();
-  // nonce → expiresAt
   sessions = /* @__PURE__ */ new Map();
-  // tokenId → session
   nonceTtlMs;
   now;
   constructor(opts = {}) {
     if (process.env.NODE_ENV === "production" && !opts.dangerouslyAllowMemoryStoreInProduction) {
-      throw new Error(
-        "[PAFI] MemorySessionStore refuses to start in production (NODE_ENV=production). Multi-pod K8s deploys do not share Map state, so sessions are not revocable across replicas \u2014 `logout` on pod A leaves the token valid on pod B until expiry. Use a Redis-backed session store (see RedisSessionStoreService in gg56-backend or implement your own ISessionStore). To bypass for a single-pod deploy, pass `dangerouslyAllowMemoryStoreInProduction: true`."
-      );
+      throw new Error("[PAFI] MemorySessionStore refuses to start in production (NODE_ENV=production). Multi-pod K8s deploys do not share Map state, so sessions are not revocable across replicas \u2014 `logout` on pod A leaves the token valid on pod B until expiry. Use a Redis-backed session store (see RedisSessionStoreService in gg56-backend or implement your own ISessionStore). To bypass for a single-pod deploy, pass `dangerouslyAllowMemoryStoreInProduction: true`.");
     }
     this.nonceTtlMs = opts.nonceTtlMs ?? DEFAULT_NONCE_TTL_MS;
     this.now = opts.now ?? (() => Date.now());
@@ -127,7 +126,9 @@ var MemorySessionStore = class {
       this.sessions.delete(tokenId);
       return null;
     }
-    return { ...session };
+    return {
+      ...session
+    };
   }
   async revokeSession(tokenId) {
     this.sessions.delete(tokenId);
@@ -159,18 +160,21 @@ var MemorySessionStore = class {
 
 // src/auth/nonceManager.ts
 var NonceManager = class {
+  static {
+    __name(this, "NonceManager");
+  }
+  store;
   constructor(store) {
     this.store = store;
   }
-  store;
   /** Generate a fresh login nonce. The store is responsible for TTL. */
   async generate() {
     return this.store.createNonce();
   }
   /**
-   * Atomically validate + consume a nonce. Returns `true` iff the nonce
-   * was known and unexpired (and is now removed from the store).
-   */
+  * Atomically validate + consume a nonce. Returns `true` iff the nonce
+  * was known and unexpired (and is now removed from the store).
+  */
   async consume(nonce) {
     return this.store.consumeNonce(nonce);
   }
@@ -202,7 +206,11 @@ function statusForCode(code) {
       return "not_found";
   }
 }
+__name(statusForCode, "statusForCode");
 var AuthError = class extends PafiSdkError {
+  static {
+    __name(this, "AuthError");
+  }
   code;
   httpStatus;
   constructor(code, message) {
@@ -215,37 +223,28 @@ var AuthError = class extends PafiSdkError {
 // src/auth/loginVerifier.ts
 function assertJwtSecretStrength(secret) {
   if (!secret) {
-    throw new Error(
-      "AuthService: jwtSecret is required. Generate via `node -e \"console.log(require('crypto').randomBytes(32).toString('hex'))\"`"
-    );
+    throw new Error("AuthService: jwtSecret is required. Generate via `node -e \"console.log(require('crypto').randomBytes(32).toString('hex'))\"`");
   }
   if (secret.length < 32) {
-    throw new Error(
-      `AuthService: jwtSecret too short (${secret.length} chars; need \u2265 32). HS256 brute-force becomes feasible below this threshold.`
-    );
+    throw new Error(`AuthService: jwtSecret too short (${secret.length} chars; need \u2265 32). HS256 brute-force becomes feasible below this threshold.`);
   }
   const uniqueChars = new Set(secret).size;
   if (uniqueChars < 16) {
-    throw new Error(
-      `AuthService: jwtSecret has only ${uniqueChars} unique characters; need \u2265 16. A trivially weak secret (e.g. "aaaaa...") will pass length but offer almost no entropy. Use \`crypto.randomBytes(32).toString('hex')\`.`
-    );
+    throw new Error(`AuthService: jwtSecret has only ${uniqueChars} unique characters; need \u2265 16. A trivially weak secret (e.g. "aaaaa...") will pass length but offer almost no entropy. Use \`crypto.randomBytes(32).toString('hex')\`.`);
   }
   const entropy = shannonEntropyBitsPerChar(secret);
   if (entropy < 3.5) {
-    throw new Error(
-      `AuthService: jwtSecret entropy too low (${entropy.toFixed(2)} bits/char; need \u2265 3.5). Use \`crypto.randomBytes(32).toString('hex')\` (\u2248 4.0 bits/char).`
-    );
+    throw new Error(`AuthService: jwtSecret entropy too low (${entropy.toFixed(2)} bits/char; need \u2265 3.5). Use \`crypto.randomBytes(32).toString('hex')\` (\u2248 4.0 bits/char).`);
   }
   for (let period = 1; period <= secret.length / 4; period++) {
     if (secret.length % period !== 0) continue;
     const head = secret.slice(0, period);
     if (secret === head.repeat(secret.length / period)) {
-      throw new Error(
-        `AuthService: jwtSecret is a repeating pattern of period ${period}. Use \`crypto.randomBytes(32).toString('hex')\`.`
-      );
+      throw new Error(`AuthService: jwtSecret is a repeating pattern of period ${period}. Use \`crypto.randomBytes(32).toString('hex')\`.`);
     }
   }
 }
+__name(assertJwtSecretStrength, "assertJwtSecretStrength");
 function shannonEntropyBitsPerChar(s) {
   const counts = /* @__PURE__ */ new Map();
   for (const c of s) counts.set(c, (counts.get(c) ?? 0) + 1);
@@ -257,6 +256,7 @@ function shannonEntropyBitsPerChar(s) {
   }
   return h;
 }
+__name(shannonEntropyBitsPerChar, "shannonEntropyBitsPerChar");
 function decodeExpiredJwtJti(token) {
   try {
     const parts = token.split(".");
@@ -266,13 +266,19 @@ function decodeExpiredJwtJti(token) {
     const padded = payloadB64.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((payloadB64.length + 3) % 4);
     const json = Buffer.from(padded, "base64").toString("utf-8");
     const claims = JSON.parse(json);
-    return typeof claims.jti === "string" ? { jti: claims.jti } : {};
+    return typeof claims.jti === "string" ? {
+      jti: claims.jti
+    } : {};
   } catch {
     return {};
   }
 }
+__name(decodeExpiredJwtJti, "decodeExpiredJwtJti");
 var DEFAULT_EXPIRES_IN = "24h";
 var AuthService = class {
+  static {
+    __name(this, "AuthService");
+  }
   sessionStore;
   jwtSecret;
   jwtExpiresIn;
@@ -302,9 +308,9 @@ var AuthService = class {
     return this.nonceManager.generate();
   }
   /**
-   * Verify a signed login message and issue a JWT on success.
-   * Throws an `AuthError` on any validation failure.
-   */
+  * Verify a signed login message and issue a JWT on success.
+  * Throws an `AuthError` on any validation failure.
+  */
   async login(message, signature) {
     let parsed;
     try {
@@ -314,46 +320,28 @@ var AuthService = class {
       throw new AuthError("INVALID_MESSAGE", `Could not parse login message: ${msg}`);
     }
     if (parsed.expirationTime == null) {
-      throw new AuthError(
-        "INVALID_MESSAGE",
-        "login message must include expirationTime"
-      );
+      throw new AuthError("INVALID_MESSAGE", "login message must include expirationTime");
     }
     if (parsed.domain !== this.domain) {
-      throw new AuthError(
-        "DOMAIN_MISMATCH",
-        `Expected domain "${this.domain}", got "${parsed.domain}"`
-      );
+      throw new AuthError("DOMAIN_MISMATCH", `Expected domain "${this.domain}", got "${parsed.domain}"`);
     }
     if (parsed.chainId !== this.chainId) {
-      throw new AuthError(
-        "CHAIN_MISMATCH",
-        `Expected chainId ${this.chainId}, got ${parsed.chainId}`
-      );
+      throw new AuthError("CHAIN_MISMATCH", `Expected chainId ${this.chainId}, got ${parsed.chainId}`);
     }
     const now = this.now();
     if (parsed.notBefore && parsed.notBefore.getTime() > now.getTime()) {
-      throw new AuthError(
-        "MESSAGE_NOT_YET_VALID",
-        "Login message is not yet valid"
-      );
+      throw new AuthError("MESSAGE_NOT_YET_VALID", "Login message is not yet valid");
     }
     if (parsed.expirationTime && parsed.expirationTime.getTime() <= now.getTime()) {
       throw new AuthError("MESSAGE_EXPIRED", "Login message has expired");
     }
     const verifyResult = await verifyLoginMessage(message, signature);
     if (!verifyResult.valid) {
-      throw new AuthError(
-        "SIGNATURE_INVALID",
-        "Signature does not match the address in the login message"
-      );
+      throw new AuthError("SIGNATURE_INVALID", "Signature does not match the address in the login message");
     }
     const nonceOk = await this.nonceManager.consume(parsed.nonce);
     if (!nonceOk) {
-      throw new AuthError(
-        "NONCE_INVALID",
-        "Nonce is unknown, expired, or already used"
-      );
+      throw new AuthError("NONCE_INVALID", "Nonce is unknown, expired, or already used");
     }
     const userAddress = getAddress2(verifyResult.address);
     const tokenId = randomBytes2(16).toString("hex");
@@ -370,11 +358,18 @@ var AuthService = class {
     let signer = new SignJWT({
       userAddress,
       chainId: this.chainId
-    }).setProtectedHeader({ alg: "HS256" }).setJti(tokenId).setIssuedAt(Math.floor(issuedAt.getTime() / 1e3)).setExpirationTime(Math.floor(expiresAt.getTime() / 1e3));
+    }).setProtectedHeader({
+      alg: "HS256"
+    }).setJti(tokenId).setIssuedAt(Math.floor(issuedAt.getTime() / 1e3)).setExpirationTime(Math.floor(expiresAt.getTime() / 1e3));
     if (this.issuer) signer = signer.setIssuer(this.issuer);
     if (this.audience) signer = signer.setAudience(this.audience);
     const token = await signer.sign(this.jwtSecret);
-    return { token, userAddress, tokenId, expiresAt };
+    return {
+      token,
+      userAddress,
+      tokenId,
+      expiresAt
+    };
   }
   /** Revoke the session backing the given JWT (logout). */
   async logout(token) {
@@ -382,9 +377,12 @@ var AuthService = class {
     try {
       const result = await jwtVerify(token, this.jwtSecret, {
         clockTolerance: 60,
-        // allow logout right after expiry
-        ...this.issuer ? { issuer: this.issuer } : {},
-        ...this.audience ? { audience: this.audience } : {}
+        ...this.issuer ? {
+          issuer: this.issuer
+        } : {},
+        ...this.audience ? {
+          audience: this.audience
+        } : {}
       });
       payload = result.payload;
     } catch (err) {
@@ -402,10 +400,7 @@ var AuthService = class {
       if (err instanceof joseErrors.JWSSignatureVerificationFailed || err instanceof joseErrors.JWSInvalid || err instanceof joseErrors.JWTInvalid) {
         throw new AuthError("TOKEN_INVALID", "JWT verification failed");
       }
-      throw new AuthError(
-        "TOKEN_INVALID",
-        `JWT verification failed: ${err instanceof Error ? err.message : String(err)}`
-      );
+      throw new AuthError("TOKEN_INVALID", `JWT verification failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     if (payload.jti) {
       try {
@@ -421,16 +416,20 @@ var AuthService = class {
     console.error("[PAFI] AuthService logout: session store error", err);
   }
   /**
-   * Verify a JWT and return the authenticated user context. Throws an
-   * `AuthError` if the token is missing, malformed, expired, revoked, or
-   * signed by a different key.
-   */
+  * Verify a JWT and return the authenticated user context. Throws an
+  * `AuthError` if the token is missing, malformed, expired, revoked, or
+  * signed by a different key.
+  */
   async verifyToken(token) {
     let payload;
     try {
       const result = await jwtVerify(token, this.jwtSecret, {
-        ...this.issuer ? { issuer: this.issuer } : {},
-        ...this.audience ? { audience: this.audience } : {}
+        ...this.issuer ? {
+          issuer: this.issuer
+        } : {},
+        ...this.audience ? {
+          audience: this.audience
+        } : {}
       });
       payload = result.payload;
     } catch (err) {
@@ -448,10 +447,7 @@ var AuthService = class {
     }
     const session = await this.sessionStore.getSession(tokenId);
     if (!session) {
-      throw new AuthError(
-        "SESSION_REVOKED",
-        "Session is no longer active (revoked or expired)"
-      );
+      throw new AuthError("SESSION_REVOKED", "Session is no longer active (revoked or expired)");
     }
     const userAddress = payload.userAddress;
     const chainId = payload.chainId;
@@ -468,51 +464,50 @@ var AuthService = class {
 function parseExpiry(from, expiresIn) {
   const match = expiresIn.match(/^(\d+)\s*(s|m|h|d)$/i);
   if (!match) {
-    throw new Error(
-      `AuthService: unsupported jwtExpiresIn "${expiresIn}" \u2014 use e.g. "24h"`
-    );
+    throw new Error(`AuthService: unsupported jwtExpiresIn "${expiresIn}" \u2014 use e.g. "24h"`);
   }
   const n = Number(match[1]);
   const unit = match[2].toLowerCase();
   const multiplier = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
   return new Date(from.getTime() + n * multiplier);
 }
+__name(parseExpiry, "parseExpiry");
 
 // src/auth/jwtMiddleware.ts
 async function authenticateRequest(authHeader, authService) {
   if (!authHeader) {
-    throw new AuthError(
-      "MISSING_TOKEN",
-      "Authorization header is required"
-    );
+    throw new AuthError("MISSING_TOKEN", "Authorization header is required");
   }
   const match = authHeader.match(/^Bearer\s+(\S+)\s*$/i);
   if (!match) {
-    throw new AuthError(
-      "MALFORMED_TOKEN",
-      "Authorization header must be in the form 'Bearer <token>'"
-    );
+    throw new AuthError("MALFORMED_TOKEN", "Authorization header must be in the form 'Bearer <token>'");
   }
   const token = match[1];
   return authService.verifyToken(token);
 }
+__name(authenticateRequest, "authenticateRequest");
 
 // src/auth/rateLimiter.ts
 var DEFAULT_LIMITS = {
-  auth_nonce: { max: 30, windowMs: 6e4 },
-  // 30 nonces/min ≈ 1 per 2s
-  auth_login: { max: 5, windowMs: 6e4 }
-  // 5 logins/min
+  auth_nonce: {
+    max: 30,
+    windowMs: 6e4
+  },
+  auth_login: {
+    max: 5,
+    windowMs: 6e4
+  }
 };
 var MemoryRateLimiter = class {
+  static {
+    __name(this, "MemoryRateLimiter");
+  }
   buckets = /* @__PURE__ */ new Map();
   limits;
   now;
   constructor(config = {}) {
     if (process.env.NODE_ENV === "production" && !process.env.PAFI_ALLOW_MEMORY_RATE_LIMITER_IN_PROD) {
-      console.warn(
-        "[PAFI] MemoryRateLimiter not safe for multi-pod K8s deploys \u2014 rate counters are NOT shared across replicas, allowing round-robin bypass. Use a Redis-backed IRateLimiter in production."
-      );
+      console.warn("[PAFI] MemoryRateLimiter not safe for multi-pod K8s deploys \u2014 rate counters are NOT shared across replicas, allowing round-robin bypass. Use a Redis-backed IRateLimiter in production.");
     }
     this.limits = {
       ...DEFAULT_LIMITS,
@@ -522,47 +517,62 @@ var MemoryRateLimiter = class {
   }
   async consume(key, action) {
     const limit = this.limits[action];
-    if (!limit) return { allowed: true };
+    if (!limit) return {
+      allowed: true
+    };
     const bucketKey = `${action}:${key}`;
     const now = this.now();
     const bucket = this.buckets.get(bucketKey);
     if (!bucket || now - bucket.windowStartedAt >= limit.windowMs) {
-      this.buckets.set(bucketKey, { count: 1, windowStartedAt: now });
-      return { allowed: true };
+      this.buckets.set(bucketKey, {
+        count: 1,
+        windowStartedAt: now
+      });
+      return {
+        allowed: true
+      };
     }
     if (bucket.count < limit.max) {
       bucket.count += 1;
-      return { allowed: true };
+      return {
+        allowed: true
+      };
     }
-    const retryAfterMs = Math.max(
-      0,
-      bucket.windowStartedAt + limit.windowMs - now
-    );
-    return { allowed: false, retryAfterMs };
+    const retryAfterMs = Math.max(0, bucket.windowStartedAt + limit.windowMs - now);
+    return {
+      allowed: false,
+      retryAfterMs
+    };
   }
   /**
-   * Test helper — clear all buckets. Not part of `IRateLimiter`; only
-   * exposed on the in-memory impl for unit tests.
-   */
+  * Test helper — clear all buckets. Not part of `IRateLimiter`; only
+  * exposed on the in-memory impl for unit tests.
+  */
   reset() {
     this.buckets.clear();
   }
 };
 var NoopRateLimiter = class {
+  static {
+    __name(this, "NoopRateLimiter");
+  }
   warned = false;
   async consume() {
     if (!this.warned && process.env.NODE_ENV === "production") {
-      console.warn(
-        "[PAFI] NoopRateLimiter active \u2014 `/auth/nonce` and `/auth/login` are NOT throttled. Wire a `MemoryRateLimiter` (dev) or Redis-backed impl (prod) via `IssuerApiHandlersConfig.rateLimiter`."
-      );
+      console.warn("[PAFI] NoopRateLimiter active \u2014 `/auth/nonce` and `/auth/login` are NOT throttled. Wire a `MemoryRateLimiter` (dev) or Redis-backed impl (prod) via `IssuerApiHandlersConfig.rateLimiter`.");
       this.warned = true;
     }
-    return { allowed: true };
+    return {
+      allowed: true
+    };
   }
 };
 
 // src/relay/types.ts
 var RelayError = class extends PafiSdkError {
+  static {
+    __name(this, "RelayError");
+  }
   httpStatus = "unprocessable";
   code;
   constructor(code, message, cause) {
@@ -575,21 +585,12 @@ var RelayError = class extends PafiSdkError {
 };
 
 // src/relay/relayService.ts
-import {
-  encodeFunctionData,
-  erc20Abi
-} from "viem";
-import {
-  POINT_TOKEN_MINT_SIG_ABI,
-  POINT_TOKEN_BURN_SIG_ABI,
-  mintFeeWrapperAbi,
-  buildPartialUserOperation,
-  signMintRequest,
-  getContractAddresses,
-  quoteOperatorFeePt,
-  Source
-} from "@pafi-dev/core";
+import { encodeFunctionData, erc20Abi } from "viem";
+import { POINT_TOKEN_MINT_SIG_ABI, POINT_TOKEN_BURN_SIG_ABI, mintFeeWrapperAbi, buildPartialUserOperation, signMintRequest, getContractAddresses, quoteOperatorFeePt, Source } from "@pafi-dev/core";
 var RelayService = class {
+  static {
+    __name(this, "RelayService");
+  }
   provider;
   chainId;
   constructor(config = {}) {
@@ -597,25 +598,28 @@ var RelayService = class {
     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.
-   */
+  * 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 ? getContractAddresses(this.chainId).pafiFeeRecipient : void 0);
     if (params.feeAmount !== void 0) {
-      return { feeAmount: params.feeAmount, feeRecipient };
+      return {
+        feeAmount: params.feeAmount,
+        feeRecipient
+      };
     }
     if (this.provider && this.chainId !== void 0) {
       const feeAmount = await quoteOperatorFeePt({
@@ -623,44 +627,39 @@ var RelayService = class {
         chainId: this.chainId,
         pointTokenAddress: params.pointTokenAddress,
         allowStaleFallback: true,
-        onFallback: (info) => {
-          console.warn(
-            `[RelayService] operatorFeeQuoter fallback (${info.source}): ${info.reason} \u2192 using ${info.fallbackValue}`
-          );
-        }
+        onFallback: /* @__PURE__ */ __name((info) => {
+          console.warn(`[RelayService] operatorFeeQuoter fallback (${info.source}): ${info.reason} \u2192 using ${info.fallbackValue}`);
+        }, "onFallback")
       });
-      return { feeAmount, feeRecipient };
+      return {
+        feeAmount,
+        feeRecipient
+      };
     }
-    return { feeAmount: 0n, feeRecipient };
+    return {
+      feeAmount: 0n,
+      feeRecipient
+    };
   }
   /**
-   * Build an unsigned UserOp for Scenario 1 (Mint) — sig-gated
-   * `PointToken.mint(to, amount, deadline, minterSig)`.
-   */
+  * Build an unsigned UserOp for Scenario 1 (Mint) — sig-gated
+  * `PointToken.mint(to, amount, deadline, minterSig)`.
+  */
   async prepareMint(params) {
     if (!params.batchExecutorAddress) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareMint: batchExecutorAddress required"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareMint: batchExecutorAddress required");
     }
     if (!params.userAddress) {
       throw new RelayError("ENCODE_FAILED", "prepareMint: userAddress required");
     }
     if (!params.pointTokenAddress) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareMint: pointTokenAddress required"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareMint: pointTokenAddress required");
     }
     if (params.amount <= 0n) {
       throw new RelayError("ENCODE_FAILED", "prepareMint: amount must be positive");
     }
     if (!params.issuerSignerWallet) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareMint: issuerSignerWallet required (for MintRequest EIP-712 signature)"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareMint: issuerSignerWallet required (for MintRequest EIP-712 signature)");
     }
     if (params.deadline <= 0n) {
       throw new RelayError("ENCODE_FAILED", "prepareMint: deadline must be positive");
@@ -671,35 +670,24 @@ var RelayService = class {
     }
     const MAX_DEADLINE_WINDOW = 3600n;
     if (params.deadline > nowSecs + MAX_DEADLINE_WINDOW) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareMint: deadline exceeds maximum allowed window (1 hour)"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareMint: deadline exceeds maximum allowed window (1 hour)");
     }
     const MINT_SOURCE = Source.EQUITY;
     const useWrapper = params.mintFeeWrapperAddress !== void 0;
     const receiverForSig = useWrapper ? params.mintFeeWrapperAddress : params.userAddress;
     let minterSig;
     try {
-      const sig = await signMintRequest(
-        params.issuerSignerWallet,
-        params.domain,
-        {
-          user: params.userAddress,
-          receiver: receiverForSig,
-          amount: params.amount,
-          source: MINT_SOURCE,
-          nonce: params.mintRequestNonce,
-          deadline: params.deadline
-        }
-      );
+      const sig = await signMintRequest(params.issuerSignerWallet, params.domain, {
+        user: params.userAddress,
+        receiver: receiverForSig,
+        amount: params.amount,
+        source: MINT_SOURCE,
+        nonce: params.mintRequestNonce,
+        deadline: params.deadline
+      });
       minterSig = sig.serialized;
     } catch (err) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        `prepareMint: failed to sign MintForRequest: ${errorMessage(err)}`,
-        err
-      );
+      throw new RelayError("ENCODE_FAILED", `prepareMint: failed to sign MintForRequest: ${errorMessage(err)}`, err);
     }
     let mintCallData;
     let mintTarget;
@@ -732,11 +720,7 @@ var RelayService = class {
         mintTarget = params.pointTokenAddress;
       }
     } catch (err) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        `prepareMint: failed to encode mint call: ${errorMessage(err)}`,
-        err
-      );
+      throw new RelayError("ENCODE_FAILED", `prepareMint: failed to encode mint call: ${errorMessage(err)}`, err);
     }
     const operations = [
       {
@@ -752,16 +736,10 @@ var RelayService = class {
     });
     if (feeAmount > 0n) {
       if (!feeRecipient) {
-        throw new RelayError(
-          "ENCODE_FAILED",
-          "prepareMint: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`."
-        );
+        throw new RelayError("ENCODE_FAILED", "prepareMint: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`.");
       }
       if (feeRecipient === "0x0000000000000000000000000000000000000000") {
-        throw new RelayError(
-          "ENCODE_FAILED",
-          "prepareMint: feeRecipient must not be zero address"
-        );
+        throw new RelayError("ENCODE_FAILED", "prepareMint: feeRecipient must not be zero address");
       }
       operations.push({
         target: params.pointTokenAddress,
@@ -769,7 +747,10 @@ var RelayService = class {
         data: encodeFunctionData({
           abi: erc20Abi,
           functionName: "transfer",
-          args: [feeRecipient, feeAmount]
+          args: [
+            feeRecipient,
+            feeAmount
+          ]
         })
       });
     }
@@ -785,29 +766,23 @@ var RelayService = class {
     });
   }
   /**
-   * Build an unsigned UserOp for Scenario 2 (Burn/Redeem) — sig-gated
-   * `PointToken.burn(from, amount, deadline, burnerSig)`. Caller
-   * provides a pre-signed `BurnRequest` + sig bytes (typically from
-   * `PTRedeemHandler`).
-   *
-   * Direct burn (no sig) is not used — every burn goes through the
-   * issuer-signed `BurnRequest` path.
-   */
+  * Build an unsigned UserOp for Scenario 2 (Burn/Redeem) — sig-gated
+  * `PointToken.burn(from, amount, deadline, burnerSig)`. Caller
+  * provides a pre-signed `BurnRequest` + sig bytes (typically from
+  * `PTRedeemHandler`).
+  *
+  * Direct burn (no sig) is not used — every burn goes through the
+  * issuer-signed `BurnRequest` path.
+  */
   async prepareBurn(params) {
     if (!params.pointTokenAddress) {
       throw new RelayError("ENCODE_FAILED", "prepareBurn: pointTokenAddress required");
     }
     if (!params.batchExecutorAddress) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareBurn: batchExecutorAddress required"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareBurn: batchExecutorAddress required");
     }
     if (!params.burnRequest || !params.burnerSignature) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        "prepareBurn: burnRequest + burnerSignature required"
-      );
+      throw new RelayError("ENCODE_FAILED", "prepareBurn: burnRequest + burnerSignature required");
     }
     let burnCallData;
     try {
@@ -823,11 +798,7 @@ var RelayService = class {
         ]
       });
     } catch (err) {
-      throw new RelayError(
-        "ENCODE_FAILED",
-        `prepareBurn: failed to encode burn call: ${errorMessage(err)}`,
-        err
-      );
+      throw new RelayError("ENCODE_FAILED", `prepareBurn: failed to encode burn call: ${errorMessage(err)}`, err);
     }
     const operations = [];
     const { feeAmount, feeRecipient } = await this.resolveFee({
@@ -837,16 +808,10 @@ var RelayService = class {
     });
     if (feeAmount > 0n) {
       if (!feeRecipient) {
-        throw new RelayError(
-          "ENCODE_FAILED",
-          "prepareBurn: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`."
-        );
+        throw new RelayError("ENCODE_FAILED", "prepareBurn: feeRecipient could not be resolved \u2014 pass `feeRecipient` explicitly or construct RelayService with a `chainId`.");
       }
       if (feeRecipient === "0x0000000000000000000000000000000000000000") {
-        throw new RelayError(
-          "ENCODE_FAILED",
-          "prepareBurn: feeRecipient must not be zero address"
-        );
+        throw new RelayError("ENCODE_FAILED", "prepareBurn: feeRecipient must not be zero address");
       }
       operations.push({
         target: params.pointTokenAddress,
@@ -854,7 +819,10 @@ var RelayService = class {
         data: encodeFunctionData({
           abi: erc20Abi,
           functionName: "transfer",
-          args: [feeRecipient, feeAmount]
+          args: [
+            feeRecipient,
+            feeAmount
+          ]
         })
       });
     }
@@ -889,10 +857,10 @@ var RelayService = class {
   // call seeds the cache; subsequent ones hit it.
   // =========================================================================
   /**
-   * Build a dummy `PartialUserOperation` for the mint scenario, suitable
-   * for `feeManager.estimateGasFee({ partialUserOp, ... })`. NO signing —
-   * uses a 65-byte zero signature placeholder.
-   */
+  * Build a dummy `PartialUserOperation` for the mint scenario, suitable
+  * for `feeManager.estimateGasFee({ partialUserOp, ... })`. NO signing —
+  * uses a 65-byte zero signature placeholder.
+  */
   previewMintUserOp(params) {
     const useWrapper = params.mintFeeWrapperAddress !== void 0;
     let mintCallData;
@@ -927,7 +895,13 @@ var RelayService = class {
     return buildPartialUserOperation({
       sender: params.userAddress,
       nonce: params.aaNonce,
-      operations: [{ target: mintTarget, value: 0n, data: mintCallData }],
+      operations: [
+        {
+          target: mintTarget,
+          value: 0n,
+          data: mintCallData
+        }
+      ],
       // Gas limits ignored by bundler estimate — it computes them.
       gasLimits: {
         callGasLimit: 1n,
@@ -953,7 +927,11 @@ var RelayService = class {
       sender: params.userAddress,
       nonce: params.aaNonce,
       operations: [
-        { target: params.pointTokenAddress, value: 0n, data: burnCallData }
+        {
+          target: params.pointTokenAddress,
+          value: 0n,
+          data: burnCallData
+        }
       ],
       gasLimits: {
         callGasLimit: 1n,
@@ -967,11 +945,15 @@ var PLACEHOLDER_SIG_65 = `0x${"00".repeat(65)}`;
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+__name(errorMessage, "errorMessage");
 
 // src/relay/feeManager.ts
 var DEFAULT_GAS_UNITS = 500000n;
 var DEFAULT_PREMIUM_BPS = 1e4;
 var FeeManager = class _FeeManager {
+  static {
+    __name(this, "FeeManager");
+  }
   provider;
   fallbackGasUnits;
   gasPremiumBps;
@@ -988,8 +970,7 @@ var FeeManager = class _FeeManager {
   static FEE_CACHE_TTL_MS = 1e4;
   constructor(config) {
     if (!config.provider) throw new Error("FeeManager: provider required");
-    if (!config.quoteNativeToFee)
-      throw new Error("FeeManager: quoteNativeToFee required");
+    if (!config.quoteNativeToFee) throw new Error("FeeManager: quoteNativeToFee required");
     this.provider = config.provider;
     this.fallbackGasUnits = config.gasUnits ?? DEFAULT_GAS_UNITS;
     this.gasPremiumBps = config.gasPremiumBps ?? DEFAULT_PREMIUM_BPS;
@@ -998,16 +979,16 @@ var FeeManager = class _FeeManager {
     this.metrics = config.metrics;
   }
   /**
-   * Estimate the operator fee for the next sponsored UserOp.
-   *
-   * Without `opts` → legacy path: `gasUnits × gasPrice × premium →
-   * quoteNativeToFee`. Cached for 10 s to absorb bursts.
-   *
-   * With `opts` AND `bundlerClient` → estimator path. Each call may
-   * hit a different bundler-cached result; the SDK does NOT add its
-   * own value cache because the estimator's cache TTL is the source
-   * of truth for "how long is this estimate good for".
-   */
+  * Estimate the operator fee for the next sponsored UserOp.
+  *
+  * Without `opts` → legacy path: `gasUnits × gasPrice × premium →
+  * quoteNativeToFee`. Cached for 10 s to absorb bursts.
+  *
+  * With `opts` AND `bundlerClient` → estimator path. Each call may
+  * hit a different bundler-cached result; the SDK does NOT add its
+  * own value cache because the estimator's cache TTL is the source
+  * of truth for "how long is this estimate good for".
+  */
   async estimateGasFee(opts = {}) {
     const isLegacyCall = !opts.partialUserOp && !opts.scenario && !opts.contractAddress;
     const now = Date.now();
@@ -1017,14 +998,12 @@ var FeeManager = class _FeeManager {
     const t0 = Date.now();
     const { gasUnits, source } = await this.resolveGasUnits(opts);
     const latencyMs = Date.now() - t0;
-    this.safeEmit(
-      () => this.metrics?.onEstimate?.({
-        source,
-        scenario: opts.scenario,
-        gasUnits,
-        latencyMs
-      })
-    );
+    this.safeEmit(() => this.metrics?.onEstimate?.({
+      source,
+      scenario: opts.scenario,
+      gasUnits,
+      latencyMs
+    }));
     const gasPrice = await this.provider.getGasPrice();
     const nativeCost = gasPrice * gasUnits;
     const withPremium = nativeCost * BigInt(this.gasPremiumBps) / 10000n;
@@ -1042,7 +1021,10 @@ var FeeManager = class _FeeManager {
   }
   async resolveGasUnits(opts) {
     if (!this.bundlerClient || !opts.partialUserOp || !opts.scenario || !opts.contractAddress) {
-      return { gasUnits: this.fallbackGasUnits, source: "fallback" };
+      return {
+        gasUnits: this.fallbackGasUnits,
+        source: "fallback"
+      };
     }
     try {
       const result = await this.bundlerClient.getGasUnits({
@@ -1051,16 +1033,20 @@ var FeeManager = class _FeeManager {
         paymasterAddress: opts.paymasterAddress,
         partialUserOp: opts.partialUserOp
       });
-      return { gasUnits: result.gasUnits, source: "estimator" };
+      return {
+        gasUnits: result.gasUnits,
+        source: "estimator"
+      };
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
-      this.safeEmit(
-        () => this.metrics?.onEstimatorError?.({
-          scenario: opts.scenario,
-          reason
-        })
-      );
-      return { gasUnits: this.fallbackGasUnits, source: "fallback" };
+      this.safeEmit(() => this.metrics?.onEstimatorError?.({
+        scenario: opts.scenario,
+        reason
+      }));
+      return {
+        gasUnits: this.fallbackGasUnits,
+        source: "fallback"
+      };
     }
   }
   safeEmit(fn) {
@@ -1073,6 +1059,9 @@ var FeeManager = class _FeeManager {
 
 // src/relay/bundlerEstimator.ts
 var PafiEstimatorHttpError = class extends Error {
+  static {
+    __name(this, "PafiEstimatorHttpError");
+  }
   status;
   body;
   constructor(status, body, message) {
@@ -1088,9 +1077,7 @@ function createPafiEstimatorClient(config) {
   if (!issuerId) throw new Error("createPafiEstimatorClient: issuerId required");
   const fetchImpl = config.fetchImpl ?? globalThis.fetch;
   if (!fetchImpl) {
-    throw new Error(
-      "createPafiEstimatorClient: no fetch implementation available \u2014 pass `fetchImpl`"
-    );
+    throw new Error("createPafiEstimatorClient: no fetch implementation available \u2014 pass `fetchImpl`");
   }
   const url = `${baseUrl.replace(/\/$/, "")}/v1/estimate-gas-fee`;
   return {
@@ -1134,15 +1121,19 @@ function createPafiEstimatorClient(config) {
     }
   };
 }
+__name(createPafiEstimatorClient, "createPafiEstimatorClient");
 
 // src/indexer/types.ts
 var InMemoryCursorStore = class _InMemoryCursorStore {
+  static {
+    __name(this, "InMemoryCursorStore");
+  }
   cursor;
   /**
-   * Child stores keyed by `forKey()`. Each child has its own cursor,
-   * so a single InMemoryCursorStore can back N PointIndexers in tests
-   * / single-process callers.
-   */
+  * Child stores keyed by `forKey()`. Each child has its own cursor,
+  * so a single InMemoryCursorStore can back N PointIndexers in tests
+  * / single-process callers.
+  */
   children = /* @__PURE__ */ new Map();
   async load() {
     return this.cursor;
@@ -1163,21 +1154,18 @@ var InMemoryCursorStore = class _InMemoryCursorStore {
 // src/indexer/pointIndexer.ts
 import { getAddress as getAddress3, parseAbiItem } from "viem";
 var PointIndexerFinalizeError = class extends Error {
-  constructor(message, context, cause) {
-    super(message);
-    this.context = context;
-    this.cause = cause;
-    this.name = "PointIndexerFinalizeError";
+  static {
+    __name(this, "PointIndexerFinalizeError");
   }
   context;
   cause;
+  constructor(message, context, cause) {
+    super(message), this.context = context, this.cause = cause;
+    this.name = "PointIndexerFinalizeError";
+  }
 };
-var TRANSFER_EVENT = parseAbiItem(
-  "event Transfer(address indexed from, address indexed to, uint256 value)"
-);
-var MINT_WITH_FEE_EVENT = parseAbiItem(
-  "event MintWithFee(address indexed pointToken, address indexed to, uint256 grossAmount, uint256 netAmount, uint256 feeAmount)"
-);
+var TRANSFER_EVENT = parseAbiItem("event Transfer(address indexed from, address indexed to, uint256 value)");
+var MINT_WITH_FEE_EVENT = parseAbiItem("event MintWithFee(address indexed pointToken, address indexed to, uint256 grossAmount, uint256 netAmount, uint256 feeAmount)");
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var DEAD_ADDRESS = "0x000000000000000000000000000000000000dEaD";
 var DEFAULT_CONFIRMATIONS = 3;
@@ -1188,7 +1176,11 @@ function isNoWrapper(addr) {
   const checksummed = getAddress3(addr);
   return checksummed === ZERO_ADDRESS || checksummed === DEAD_ADDRESS;
 }
+__name(isNoWrapper, "isNoWrapper");
 var PointIndexer = class {
+  static {
+    __name(this, "PointIndexer");
+  }
   provider;
   pointTokenAddress;
   mintFeeWrapperAddress;
@@ -1203,8 +1195,7 @@ var PointIndexer = class {
   timer;
   constructor(config) {
     if (!config.provider) throw new Error("PointIndexer: provider required");
-    if (!config.pointTokenAddress)
-      throw new Error("PointIndexer: pointTokenAddress required");
+    if (!config.pointTokenAddress) throw new Error("PointIndexer: pointTokenAddress required");
     if (!config.ledger) throw new Error("PointIndexer: ledger required");
     this.provider = config.provider;
     this.pointTokenAddress = getAddress3(config.pointTokenAddress);
@@ -1235,10 +1226,10 @@ var PointIndexer = class {
     }
   }
   /**
-   * Run one poll cycle: load cursor → scan [cursor, safeHead] in
-   * `batchSize` chunks → persist new cursor. Swallows any error and
-   * schedules the next tick. Visible for test harnesses via a public name.
-   */
+  * Run one poll cycle: load cursor → scan [cursor, safeHead] in
+  * `batchSize` chunks → persist new cursor. Swallows any error and
+  * schedules the next tick. Visible for test harnesses via a public name.
+  */
   async tick() {
     if (!this.running) return;
     try {
@@ -1273,19 +1264,16 @@ var PointIndexer = class {
   }
   scheduleNext() {
     if (!this.running) return;
-    this.timer = setTimeout(
-      () => this.tick().catch((err) => this.handleTickError(err)),
-      this.pollIntervalMs
-    );
+    this.timer = setTimeout(() => this.tick().catch((err) => this.handleTickError(err)), this.pollIntervalMs);
   }
   // -------------------------------------------------------------------------
   // Block scanning
   // -------------------------------------------------------------------------
   /**
-   * Scan `[from, to]` inclusive for mint events in `batchSize` chunks.
-   * Callers can use this directly to backfill a specific range without
-   * engaging `start()`. On completion, the cursor is advanced to `to + 1`.
-   */
+  * Scan `[from, to]` inclusive for mint events in `batchSize` chunks.
+  * Callers can use this directly to backfill a specific range without
+  * engaging `start()`. On completion, the cursor is advanced to `to + 1`.
+  */
   async processBlockRange(from, to) {
     if (from > to) return;
     let cursor = from;
@@ -1309,15 +1297,17 @@ var PointIndexer = class {
   // Event fetching — two modes (wrapper vs direct)
   // -------------------------------------------------------------------------
   /**
-   * Wrapper mode: listen for `MintWithFee` on the wrapper,
-   * filtered to events for THIS pointToken only. The event's `to` field
-   * is the actual end user, and `grossAmount` matches the lock amount.
-   */
+  * Wrapper mode: listen for `MintWithFee` on the wrapper,
+  * filtered to events for THIS pointToken only. The event's `to` field
+  * is the actual end user, and `grossAmount` matches the lock amount.
+  */
   async fetchWrapperMintEvents(fromBlock, toBlock) {
     const logs = await this.provider.getLogs({
       address: this.mintFeeWrapperAddress,
       event: MINT_WITH_FEE_EVENT,
-      args: { pointToken: this.pointTokenAddress },
+      args: {
+        pointToken: this.pointTokenAddress
+      },
       fromBlock,
       toBlock
     });
@@ -1339,14 +1329,16 @@ var PointIndexer = class {
     return out;
   }
   /**
-   * Direct mode (legacy / chains without wrapper): listen for
-   * `Transfer(from=0x0 → to)` on the PointToken itself.
-   */
+  * Direct mode (legacy / chains without wrapper): listen for
+  * `Transfer(from=0x0 → to)` on the PointToken itself.
+  */
   async fetchTransferMintEvents(fromBlock, toBlock) {
     const logs = await this.provider.getLogs({
       address: this.pointTokenAddress,
       event: TRANSFER_EVENT,
-      args: { from: ZERO_ADDRESS },
+      args: {
+        from: ZERO_ADDRESS
+      },
       fromBlock,
       toBlock
     });
@@ -1373,42 +1365,30 @@ var PointIndexer = class {
   // Finalization
   // -------------------------------------------------------------------------
   /**
-   * Finalize a single mint event: match it to a PENDING lock in the
-   * ledger, then call `deductBalance` (which also resolves the lock in
-   * the default `MemoryPointLedger`).
-   *
-   * No-matching-lock is a valid state: it means either the lock already
-   * expired, or the mint was authorized out-of-band (e.g. a direct
-   * `PointToken.mint()` from an EOA minter for testing). In that case we
-   * do NOT touch the ledger — crediting here would silently allow the
-   * issuer to mint without going through the gateway.
-   */
+  * Finalize a single mint event: match it to a PENDING lock in the
+  * ledger, then call `deductBalance` (which also resolves the lock in
+  * the default `MemoryPointLedger`).
+  *
+  * No-matching-lock is a valid state: it means either the lock already
+  * expired, or the mint was authorized out-of-band (e.g. a direct
+  * `PointToken.mint()` from an EOA minter for testing). In that case we
+  * do NOT touch the ledger — crediting here would silently allow the
+  * issuer to mint without going through the gateway.
+  */
   async finalize(evt) {
-    const locks = await this.ledger.getLockedRequests(
-      evt.to,
-      this.pointTokenAddress
-    );
+    const locks = await this.ledger.getLockedRequests(evt.to, this.pointTokenAddress);
     const match = pickMatchingLock(locks, evt.amount);
     if (!match) return;
     try {
-      await this.ledger.deductBalance(
-        evt.to,
-        evt.amount,
-        evt.txHash,
-        this.pointTokenAddress
-      );
+      await this.ledger.deductBalance(evt.to, evt.amount, evt.txHash, this.pointTokenAddress);
     } catch (err) {
-      throw new PointIndexerFinalizeError(
-        `PointIndexer.deductBalance failed for tx ${evt.txHash} (to=${evt.to}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`,
-        {
-          pointToken: this.pointTokenAddress,
-          to: evt.to,
-          amount: evt.amount,
-          txHash: evt.txHash,
-          blockNumber: evt.blockNumber
-        },
-        err
-      );
+      throw new PointIndexerFinalizeError(`PointIndexer.deductBalance failed for tx ${evt.txHash} (to=${evt.to}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`, {
+        pointToken: this.pointTokenAddress,
+        to: evt.to,
+        amount: evt.amount,
+        txHash: evt.txHash,
+        blockNumber: evt.blockNumber
+      }, err);
     }
     try {
       await this.ledger.updateMintStatus(match.lockId, "MINTED", evt.txHash);
@@ -1427,32 +1407,35 @@ function pickMatchingLock(locks, amount) {
   }
   return best;
 }
+__name(pickMatchingLock, "pickMatchingLock");
 
 // src/indexer/burnIndexer.ts
 import { getAddress as getAddress4, parseAbiItem as parseAbiItem2 } from "viem";
 var BurnIndexerFinalizeError = class extends Error {
-  constructor(message, context, cause) {
-    super(message);
-    this.context = context;
-    this.cause = cause;
-    this.name = "BurnIndexerFinalizeError";
+  static {
+    __name(this, "BurnIndexerFinalizeError");
   }
   context;
   cause;
+  constructor(message, context, cause) {
+    super(message), this.context = context, this.cause = cause;
+    this.name = "BurnIndexerFinalizeError";
+  }
 };
-var TRANSFER_EVENT2 = parseAbiItem2(
-  "event Transfer(address indexed from, address indexed to, uint256 value)"
-);
+var TRANSFER_EVENT2 = parseAbiItem2("event Transfer(address indexed from, address indexed to, uint256 value)");
 var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var DEFAULT_CONFIRMATIONS2 = 3;
 var DEFAULT_BATCH_SIZE2 = 2000n;
 var DEFAULT_POLL_INTERVAL_MS2 = 5e3;
 var BurnIndexer = class {
+  static {
+    __name(this, "BurnIndexer");
+  }
   provider;
   /**
-   * The PointToken this indexer watches. Exposed so callers can key
-   * leader-election locks / cursor stores by token
-   */
+  * The PointToken this indexer watches. Exposed so callers can key
+  * leader-election locks / cursor stores by token
+  */
   pointTokenAddress;
   ledger;
   cursorStore;
@@ -1466,24 +1449,19 @@ var BurnIndexer = class {
   timer;
   constructor(config) {
     if (!config.provider) throw new Error("BurnIndexer: provider required");
-    if (!config.pointTokenAddress)
-      throw new Error("BurnIndexer: pointTokenAddress required");
+    if (!config.pointTokenAddress) throw new Error("BurnIndexer: pointTokenAddress required");
     if (!config.ledger) throw new Error("BurnIndexer: ledger required");
     this.provider = config.provider;
     this.pointTokenAddress = config.pointTokenAddress;
     this.ledger = config.ledger;
     this.cursorStore = config.cursorStore ?? new InMemoryCursorStore();
     this.startBlock = config.fromBlock ?? 0n;
-    this.confirmations = BigInt(
-      config.confirmations ?? DEFAULT_CONFIRMATIONS2
-    );
+    this.confirmations = BigInt(config.confirmations ?? DEFAULT_CONFIRMATIONS2);
     this.batchSize = BigInt(config.batchSize ?? Number(DEFAULT_BATCH_SIZE2));
     this.pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
     if (config.onTickError) this.onTickError = config.onTickError;
     if (!config.matchLockId) {
-      throw new Error(
-        "BurnIndexer: matchLockId is required. Provide a function that maps a burn event to its pending credit lockId. Without it, no on-chain burns will ever grant off-chain credits."
-      );
+      throw new Error("BurnIndexer: matchLockId is required. Provide a function that maps a burn event to its pending credit lockId. Without it, no on-chain burns will ever grant off-chain credits.");
     }
     this.matchLockId = config.matchLockId;
   }
@@ -1533,16 +1511,13 @@ var BurnIndexer = class {
   }
   scheduleNext() {
     if (!this.running) return;
-    this.timer = setTimeout(
-      () => this.tick().catch((err) => this.handleTickError(err)),
-      this.pollIntervalMs
-    );
+    this.timer = setTimeout(() => this.tick().catch((err) => this.handleTickError(err)), this.pollIntervalMs);
   }
   /**
-   * Scan `[from, to]` inclusive for burn events. Callers can drive this
-   * directly to backfill a specific range without `start()`. Cursor is
-   * advanced to `to + 1` on completion.
-   */
+  * Scan `[from, to]` inclusive for burn events. Callers can drive this
+  * directly to backfill a specific range without `start()`. Cursor is
+  * advanced to `to + 1` on completion.
+  */
   async processBlockRange(from, to) {
     if (from > to) return;
     let cursor = from;
@@ -1551,8 +1526,9 @@ var BurnIndexer = class {
       const logs = await this.provider.getLogs({
         address: this.pointTokenAddress,
         event: TRANSFER_EVENT2,
-        args: { to: ZERO_ADDRESS2 },
-        // filter: burn = transfer to zero
+        args: {
+          to: ZERO_ADDRESS2
+        },
         fromBlock: cursor,
         toBlock: chunkEnd
       });
@@ -1588,17 +1564,15 @@ var BurnIndexer = class {
     return out;
   }
   /**
-   * Resolve a matching pending credit for this burn event and call
-   * `ledger.resolveCreditByBurnTx(lockId, txHash)`. If no match found,
-   * log + skip.
-   */
+  * Resolve a matching pending credit for this burn event and call
+  * `ledger.resolveCreditByBurnTx(lockId, txHash)`. If no match found,
+  * log + skip.
+  */
   async finalize(evt) {
     const txHash = evt.txHash;
     const lockId = await this.matchLockId(evt);
     if (lockId === void 0) {
-      console.warn(
-        "[PAFI] BurnIndexer: matchLockId returned undefined for burn tx " + txHash + ". This burn will NOT be credited. Implement matchLockId to map burn events to lock IDs."
-      );
+      console.warn("[PAFI] BurnIndexer: matchLockId returned undefined for burn tx " + txHash + ". This burn will NOT be credited. Implement matchLockId to map burn events to lock IDs.");
       return;
     }
     if (!this.ledger.resolveCreditByBurnTx) {
@@ -1607,18 +1581,14 @@ var BurnIndexer = class {
     try {
       await this.ledger.resolveCreditByBurnTx(lockId, evt.txHash);
     } catch (err) {
-      throw new BurnIndexerFinalizeError(
-        `BurnIndexer.resolveCreditByBurnTx failed for tx ${evt.txHash} (lockId=${lockId}, from=${evt.from}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`,
-        {
-          pointToken: this.pointTokenAddress,
-          from: evt.from,
-          amount: evt.amount,
-          txHash: evt.txHash,
-          blockNumber: evt.blockNumber,
-          lockId
-        },
-        err
-      );
+      throw new BurnIndexerFinalizeError(`BurnIndexer.resolveCreditByBurnTx failed for tx ${evt.txHash} (lockId=${lockId}, from=${evt.from}, amount=${evt.amount}, block=${evt.blockNumber}); cursor will NOT advance, next tick retries.`, {
+        pointToken: this.pointTokenAddress,
+        from: evt.from,
+        amount: evt.amount,
+        txHash: evt.txHash,
+        blockNumber: evt.blockNumber,
+        lockId
+      }, err);
     }
   }
 };
@@ -1628,10 +1598,9 @@ function makePostgresSingletonLock(runner) {
   return {
     async acquire(key) {
       const lockId = hashKeyToInt64(key);
-      const rows = await runner.query(
-        "SELECT pg_try_advisory_lock($1::bigint) AS got",
-        [lockId]
-      );
+      const rows = await runner.query("SELECT pg_try_advisory_lock($1::bigint) AS got", [
+        lockId
+      ]);
       const got = rows[0]?.got === true;
       if (!got) return null;
       return {
@@ -1647,6 +1616,7 @@ function makePostgresSingletonLock(runner) {
     }
   };
 }
+__name(makePostgresSingletonLock, "makePostgresSingletonLock");
 function hashKeyToInt64(key) {
   const FNV_OFFSET = 0xcbf29ce484222325n;
   const FNV_PRIME = 0x100000001b3n;
@@ -1661,22 +1631,22 @@ function hashKeyToInt64(key) {
   const signed = hash > SIGNED_MAX ? hash - TWO64 : hash;
   return signed.toString();
 }
+__name(hashKeyToInt64, "hashKeyToInt64");
 
 // src/api/handlers.ts
 import { getAddress as getAddress5 } from "viem";
-import {
-  getMintFeeBps,
-  getPointTokenBalance,
-  isMinter
-} from "@pafi-dev/core";
+import { getMintFeeBps, getPointTokenBalance, isMinter } from "@pafi-dev/core";
 var IssuerApiHandlers = class _IssuerApiHandlers {
+  static {
+    __name(this, "IssuerApiHandlers");
+  }
   authService;
   ledger;
   provider;
   /**
-   * Set of supported PointToken addresses (checksum-normalized). Handlers
-   * validate the request's `pointTokenAddress` against this set.
-   */
+  * Set of supported PointToken addresses (checksum-normalized). Handlers
+  * validate the request's `pointTokenAddress` against this set.
+  */
   supportedTokens;
   chainId;
   contracts;
@@ -1687,10 +1657,10 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
   rateLimiter;
   mintFeeWrapperAddress;
   /**
-   * Per-token feeBps cache. Refreshed on /config when stale. feeBps
-   * changes only when ops calls `wrapper.setRecipients`, so 5-min TTL
-   * is more than safe for FE display purposes.
-   */
+  * Per-token feeBps cache. Refreshed on /config when stale. feeBps
+  * changes only when ops calls `wrapper.setRecipients`, so 5-min TTL
+  * is more than safe for FE display purposes.
+  */
   feeBpsCache = /* @__PURE__ */ new Map();
   static FEE_BPS_TTL_MS = 5 * 60 * 1e3;
   constructor(config) {
@@ -1698,11 +1668,11 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
     this.ledger = config.ledger;
     this.provider = config.provider;
     this.rateLimiter = config.rateLimiter ?? new NoopRateLimiter();
-    const raw = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [config.pointTokenAddress] : [];
+    const raw = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [
+      config.pointTokenAddress
+    ] : [];
     if (raw.length === 0) {
-      throw new Error(
-        "IssuerApiHandlers: pointTokenAddress or pointTokenAddresses required"
-      );
+      throw new Error("IssuerApiHandlers: pointTokenAddress or pointTokenAddresses required");
     }
     const normalized = raw.map((a) => getAddress5(a));
     this.supportedTokens = new Set(normalized);
@@ -1720,63 +1690,48 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
   // Public handlers (no auth required)
   // =========================================================================
   /**
-   * `GET /auth/nonce`
-   *
-   * @param rateLimitKey  Caller-side rate-limit key (typically client IP).
-   *                      The HTTP layer (controller/middleware) extracts
-   *                      this from the request and passes it through.
-   *                      When omitted, no rate limit applies — production
-   *                      callers SHOULD always pass a key.
-   */
+  * `GET /auth/nonce`
+  *
+  * @param rateLimitKey  Caller-side rate-limit key (typically client IP).
+  *                      The HTTP layer (controller/middleware) extracts
+  *                      this from the request and passes it through.
+  *                      When omitted, no rate limit applies — production
+  *                      callers SHOULD always pass a key.
+  */
   async handleGetNonce(rateLimitKey) {
     if (rateLimitKey) {
-      const result = await this.rateLimiter.consume(
-        rateLimitKey,
-        "auth_nonce"
-      );
+      const result = await this.rateLimiter.consume(rateLimitKey, "auth_nonce");
       if (!result.allowed) {
-        throw new ValidationError(
-          "RATE_LIMIT_EXCEEDED",
-          "handleGetNonce: too many requests",
-          {
-            retryAfterMs: result.retryAfterMs ?? 0,
-            action: "auth_nonce"
-          }
-        );
+        throw new ValidationError("RATE_LIMIT_EXCEEDED", "handleGetNonce: too many requests", {
+          retryAfterMs: result.retryAfterMs ?? 0,
+          action: "auth_nonce"
+        });
       }
     }
     const nonce = await this.authService.getNonce();
-    return { nonce };
+    return {
+      nonce
+    };
   }
   /**
-   * `POST /auth/login`
-   *
-   * @param body          Login message + signature.
-   * @param rateLimitKey  Caller-side rate-limit key (typically client IP
-   *                      or `body.userAddress` if known). See `handleGetNonce`.
-   */
+  * `POST /auth/login`
+  *
+  * @param body          Login message + signature.
+  * @param rateLimitKey  Caller-side rate-limit key (typically client IP
+  *                      or `body.userAddress` if known). See `handleGetNonce`.
+  */
   async handleLogin(body, rateLimitKey) {
     if (rateLimitKey) {
-      const result2 = await this.rateLimiter.consume(
-        rateLimitKey,
-        "auth_login"
-      );
+      const result2 = await this.rateLimiter.consume(rateLimitKey, "auth_login");
       if (!result2.allowed) {
-        throw new ValidationError(
-          "RATE_LIMIT_EXCEEDED",
-          "handleLogin: too many requests",
-          {
-            retryAfterMs: result2.retryAfterMs ?? 0,
-            action: "auth_login"
-          }
-        );
+        throw new ValidationError("RATE_LIMIT_EXCEEDED", "handleLogin: too many requests", {
+          retryAfterMs: result2.retryAfterMs ?? 0,
+          action: "auth_login"
+        });
       }
     }
     if (!body || typeof body.message !== "string" || body.message.length === 0 || typeof body.signature !== "string" || body.signature.length <= 2) {
-      throw new ValidationError(
-        "INVALID_LOGIN_BODY",
-        "handleLogin: message and signature are required"
-      );
+      throw new ValidationError("INVALID_LOGIN_BODY", "handleLogin: message and signature are required");
     }
     if (body.message.length > 4096) {
       throw new ValidationError("MESSAGE_TOO_LONG", "message too long");
@@ -1792,11 +1747,11 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
     };
   }
   /**
-   * `GET /config?chainId=<id>`
-   *
-   * Returns the contract addresses and chain id that the frontend SDK
-   * needs to build EIP-712 messages and interact with on-chain.
-   */
+  * `GET /config?chainId=<id>`
+  *
+  * Returns the contract addresses and chain id that the frontend SDK
+  * needs to build EIP-712 messages and interact with on-chain.
+  */
   async handleConfig(chainId) {
     if (!Number.isInteger(chainId) || chainId <= 0) {
       throw new ValidationError("INVALID_CHAIN_ID", "invalid chainId", {
@@ -1804,11 +1759,10 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
       });
     }
     if (chainId !== this.chainId) {
-      throw new ValidationError(
-        "UNSUPPORTED_CHAIN_ID",
-        `handleConfig: unsupported chainId ${chainId}`,
-        { requested: chainId, supported: this.chainId }
-      );
+      throw new ValidationError("UNSUPPORTED_CHAIN_ID", `handleConfig: unsupported chainId ${chainId}`, {
+        requested: chainId,
+        supported: this.chainId
+      });
     }
     const contracts = {
       ...this.contracts,
@@ -1822,60 +1776,55 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
       contracts
     };
     if (this.mintFeeWrapperAddress) {
-      const byToken = await this.resolveFeeBpsByToken(
-        this.mintFeeWrapperAddress
-      );
+      const byToken = await this.resolveFeeBpsByToken(this.mintFeeWrapperAddress);
       if (byToken) response.mintFeeBpsByToken = byToken;
     }
     if (this.pafiWebUrl) response.pafiWebUrl = this.pafiWebUrl;
     return response;
   }
   /**
-   * Read `totalFeeBps(pointToken)` for every supported PointToken from
-   * the wrapper. Cached per-token for 5 minutes. Returns `undefined`
-   * (caller drops the field) if every read fails — FE must treat
-   * "field missing" as "fee unknown, do not display".
-   */
+  * Read `totalFeeBps(pointToken)` for every supported PointToken from
+  * the wrapper. Cached per-token for 5 minutes. Returns `undefined`
+  * (caller drops the field) if every read fails — FE must treat
+  * "field missing" as "fee unknown, do not display".
+  */
   async resolveFeeBpsByToken(wrapper) {
     const now = Date.now();
     const out = {};
     let anyFresh = false;
-    await Promise.all(
-      Array.from(this.supportedTokens).map(async (token) => {
-        const cached = this.feeBpsCache.get(token);
-        if (cached && cached.expiresAt > now) {
+    await Promise.all(Array.from(this.supportedTokens).map(async (token) => {
+      const cached = this.feeBpsCache.get(token);
+      if (cached && cached.expiresAt > now) {
+        out[token.toLowerCase()] = cached.value;
+        anyFresh = true;
+        return;
+      }
+      try {
+        const bps = await getMintFeeBps(this.provider, wrapper, token);
+        this.feeBpsCache.set(token, {
+          value: bps,
+          expiresAt: now + _IssuerApiHandlers.FEE_BPS_TTL_MS
+        });
+        out[token.toLowerCase()] = bps;
+        anyFresh = true;
+      } catch {
+        if (cached) {
           out[token.toLowerCase()] = cached.value;
           anyFresh = true;
-          return;
         }
-        try {
-          const bps = await getMintFeeBps(this.provider, wrapper, token);
-          this.feeBpsCache.set(token, {
-            value: bps,
-            expiresAt: now + _IssuerApiHandlers.FEE_BPS_TTL_MS
-          });
-          out[token.toLowerCase()] = bps;
-          anyFresh = true;
-        } catch {
-          if (cached) {
-            out[token.toLowerCase()] = cached.value;
-            anyFresh = true;
-          }
-        }
-      })
-    );
+      }
+    }));
     return anyFresh ? out : void 0;
   }
   /** `GET /gas-fee` — quoted in USDT (6-decimal base units). */
   async handleGasFee() {
     if (!this.feeManager) {
-      throw new ConfigurationError(
-        "FEE_MANAGER_NOT_CONFIGURED",
-        "handleGasFee: feeManager is not configured on this issuer"
-      );
+      throw new ConfigurationError("FEE_MANAGER_NOT_CONFIGURED", "handleGasFee: feeManager is not configured on this issuer");
     }
     const gasFeeUsdt = await this.feeManager.estimateGasFee();
-    return { gasFeeUsdt };
+    return {
+      gasFeeUsdt
+    };
   }
   // =========================================================================
   // Protected handlers (JWT required — userAddress extracted by middleware)
@@ -1885,57 +1834,49 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
     await this.authService.logout(token);
   }
   /**
-   * `GET /pools?chainId=<id>&pointToken=<addr>`
-   *
-   * Delegates to the injected `PoolsProvider`. The handler itself does
-   * not know where pools come from — that's an issuer decision.
-   */
+  * `GET /pools?chainId=<id>&pointToken=<addr>`
+  *
+  * Delegates to the injected `PoolsProvider`. The handler itself does
+  * not know where pools come from — that's an issuer decision.
+  */
   async handlePools(_userAddress, request) {
     if (!this.poolsProvider) {
-      throw new ConfigurationError(
-        "POOLS_PROVIDER_NOT_CONFIGURED",
-        "handlePools: poolsProvider is not configured on this issuer"
-      );
+      throw new ConfigurationError("POOLS_PROVIDER_NOT_CONFIGURED", "handlePools: poolsProvider is not configured on this issuer");
     }
     if (request.chainId !== this.chainId) {
-      throw new ValidationError(
-        "UNSUPPORTED_CHAIN_ID",
-        `handlePools: unsupported chainId ${request.chainId}`,
-        { requested: request.chainId, supported: this.chainId }
-      );
+      throw new ValidationError("UNSUPPORTED_CHAIN_ID", `handlePools: unsupported chainId ${request.chainId}`, {
+        requested: request.chainId,
+        supported: this.chainId
+      });
     }
     return this.poolsProvider(request);
   }
   /**
-   * `GET /user?chainId=<id>&user=<addr>&pointToken=<addr>`
-   *
-   * Returns per-user state the frontend needs to build a fresh mint:
-   * on-chain nonces + minter status + off-chain balance.
-   */
+  * `GET /user?chainId=<id>&user=<addr>&pointToken=<addr>`
+  *
+  * Returns per-user state the frontend needs to build a fresh mint:
+  * on-chain nonces + minter status + off-chain balance.
+  */
   async handleUser(userAddress, request) {
     if (request.chainId !== this.chainId) {
-      throw new ValidationError(
-        "UNSUPPORTED_CHAIN_ID",
-        `handleUser: unsupported chainId ${request.chainId}`,
-        { requested: request.chainId, supported: this.chainId }
-      );
+      throw new ValidationError("UNSUPPORTED_CHAIN_ID", `handleUser: unsupported chainId ${request.chainId}`, {
+        requested: request.chainId,
+        supported: this.chainId
+      });
     }
     const normalizedAuthed = getAddress5(userAddress);
     const normalizedRequest = getAddress5(request.userAddress);
     if (normalizedAuthed !== normalizedRequest) {
-      throw new ValidationError(
-        "USER_ADDRESS_MISMATCH",
-        "handleUser: request userAddress must match authenticated user",
-        { authenticated: normalizedAuthed, requested: normalizedRequest }
-      );
+      throw new ValidationError("USER_ADDRESS_MISMATCH", "handleUser: request userAddress must match authenticated user", {
+        authenticated: normalizedAuthed,
+        requested: normalizedRequest
+      });
     }
     const pointToken = getAddress5(request.pointTokenAddress);
     if (!this.supportedTokens.has(pointToken)) {
-      throw new ValidationError(
-        "UNSUPPORTED_POINT_TOKEN",
-        `handleUser: unsupported pointToken ${pointToken}`,
-        { requested: pointToken }
-      );
+      throw new ValidationError("UNSUPPORTED_POINT_TOKEN", `handleUser: unsupported pointToken ${pointToken}`, {
+        requested: pointToken
+      });
     }
     const [offChainBalance, onChainBalance, minter] = await Promise.all([
       this.ledger.getBalance(normalizedAuthed, pointToken),
@@ -1947,7 +1888,6 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
       onChainBalance,
       totalBalance: offChainBalance + onChainBalance,
       balance: offChainBalance,
-      // deprecated alias
       isMinter: minter
     };
   }
@@ -1955,56 +1895,41 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
   // removed in 0.5.43 — callers should use `PTClaimHandler` directly or
   // wire `IssuerApiAdapter.claim()` which composes the full flow.
   /**
-   * `GET /redemption/preview?pointToken=<addr>`
-   *
-   * Returns the headroom currently available to `userAddress` under the
-   * configured RedemptionPolicy. Pure read — does not record anything.
-   * Use this for UI to render "X PT redeemable now / next available at …".
-   */
+  * `GET /redemption/preview?pointToken=<addr>`
+  *
+  * Returns the headroom currently available to `userAddress` under the
+  * configured RedemptionPolicy. Pure read — does not record anything.
+  * Use this for UI to render "X PT redeemable now / next available at …".
+  */
   async handleRedemptionPreview(userAddress, request) {
     if (!this.redemption) {
-      throw new ConfigurationError(
-        "REDEMPTION_NOT_CONFIGURED",
-        "handleRedemptionPreview: redemption is not configured on this issuer"
-      );
+      throw new ConfigurationError("REDEMPTION_NOT_CONFIGURED", "handleRedemptionPreview: redemption is not configured on this issuer");
     }
     const tokenAddress = request.pointTokenAddress ? this.requireSupportedToken(getAddress5(request.pointTokenAddress), "handleRedemptionPreview") : void 0;
-    const preview = await this.redemption.preview(
-      getAddress5(userAddress),
-      tokenAddress
-    );
+    const preview = await this.redemption.preview(getAddress5(userAddress), tokenAddress);
     return preview;
   }
   /**
-   * `POST /redemption/evaluate`
-   *
-   * Pre-flight check before the issuer signs a BurnRequest. Returns
-   * { allowed, denial?, preview }. Caller (the burn-orchestrator) MUST
-   * re-check on the actual initiate path — evaluate is read-only and a
-   * caller could race two requests under the same headroom. The intended
-   * write path is: evaluate → sign BurnRequest → reserve pending credit
-   * → call `service.redemption.recordSuccessfulInitiate()`.
-   */
+  * `POST /redemption/evaluate`
+  *
+  * Pre-flight check before the issuer signs a BurnRequest. Returns
+  * { allowed, denial?, preview }. Caller (the burn-orchestrator) MUST
+  * re-check on the actual initiate path — evaluate is read-only and a
+  * caller could race two requests under the same headroom. The intended
+  * write path is: evaluate → sign BurnRequest → reserve pending credit
+  * → call `service.redemption.recordSuccessfulInitiate()`.
+  */
   async handleRedemptionEvaluate(userAddress, request) {
     if (!this.redemption) {
-      throw new ConfigurationError(
-        "REDEMPTION_NOT_CONFIGURED",
-        "handleRedemptionEvaluate: redemption is not configured on this issuer"
-      );
+      throw new ConfigurationError("REDEMPTION_NOT_CONFIGURED", "handleRedemptionEvaluate: redemption is not configured on this issuer");
     }
     if (request.amountPt <= 0n) {
-      throw new ValidationError(
-        "INVALID_AMOUNT",
-        "handleRedemptionEvaluate: amountPt must be positive",
-        { amountPt: request.amountPt.toString() }
-      );
+      throw new ValidationError("INVALID_AMOUNT", "handleRedemptionEvaluate: amountPt must be positive", {
+        amountPt: request.amountPt.toString()
+      });
     }
     const tokenAddress = request.pointTokenAddress ? this.requireSupportedToken(getAddress5(request.pointTokenAddress), "handleRedemptionEvaluate") : void 0;
-    const decision = await this.redemption.evaluate(
-      getAddress5(userAddress),
-      request.amountPt,
-      tokenAddress
-    );
+    const decision = await this.redemption.evaluate(getAddress5(userAddress), request.amountPt, tokenAddress);
     const response = {
       allowed: decision.allowed,
       preview: decision.preview
@@ -2014,11 +1939,9 @@ var IssuerApiHandlers = class _IssuerApiHandlers {
   }
   requireSupportedToken(pointToken, handler) {
     if (!this.supportedTokens.has(pointToken)) {
-      throw new ValidationError(
-        "UNSUPPORTED_POINT_TOKEN",
-        `${handler}: unsupported pointToken ${pointToken}`,
-        { requested: pointToken }
-      );
+      throw new ValidationError("UNSUPPORTED_POINT_TOKEN", `${handler}: unsupported pointToken ${pointToken}`, {
+        requested: pointToken
+      });
     }
     return pointToken;
   }
@@ -2032,10 +1955,17 @@ var NAME_ABI = [
     name: "name",
     stateMutability: "view",
     inputs: [],
-    outputs: [{ type: "string" }]
+    outputs: [
+      {
+        type: "string"
+      }
+    ]
   }
 ];
 var PointTokenDomainResolver = class {
+  static {
+    __name(this, "PointTokenDomainResolver");
+  }
   provider;
   overrides;
   cache = /* @__PURE__ */ new Map();
@@ -2077,17 +2007,14 @@ var PointTokenDomainResolver = class {
 
 // src/api/handlers/ptRedeemHandler.ts
 import { getAddress as getAddress7 } from "viem";
-import {
-  signBurnRequest,
-  POINT_TOKEN_ABI,
-  getPointTokenBalance as getPointTokenBalance2,
-  getContractAddresses as getContractAddresses2,
-  Source as Source2
-} from "@pafi-dev/core";
+import { signBurnRequest, POINT_TOKEN_ABI, getPointTokenBalance as getPointTokenBalance2, getContractAddresses as getContractAddresses2, Source as Source2 } from "@pafi-dev/core";
 var DEFAULT_REDEEM_LOCK_MS = 15 * 60 * 1e3;
 var M11_SAFETY_MARGIN_MS = 30 * 1e3;
 var DEFAULT_SIG_DEADLINE_SEC = (DEFAULT_REDEEM_LOCK_MS - M11_SAFETY_MARGIN_MS) / 1e3;
 var PTRedeemError = class extends PafiSdkError {
+  static {
+    __name(this, "PTRedeemError");
+  }
   httpStatus = "unprocessable";
   code;
   policyDenialCode;
@@ -2100,6 +2027,9 @@ var PTRedeemError = class extends PafiSdkError {
   }
 };
 var PTRedeemHandler = class {
+  static {
+    __name(this, "PTRedeemHandler");
+  }
   ledger;
   relayService;
   provider;
@@ -2114,31 +2044,25 @@ var PTRedeemHandler = class {
   now;
   redemptionService;
   /**
-   * Per-user in-flight nonce guard (single-process only).
-   *
-   * Prevents two concurrent requests from reading the same on-chain
-   * burnRequestNonce before either has completed, which would produce two
-   * signed UserOps with the same nonce — only one succeeds on-chain; the
-   * other leaves an orphaned pending credit and a wasted signer call.
-   *
-   * NOTE: This guard is effective only within a single Node.js process. For
-   * multi-instance deployments (k8s, PM2 cluster), enforce mutual exclusion
-   * via a distributed lock (Redis SETNX / Postgres advisory lock) keyed on
-   * `(userAddress, pointTokenAddress)` BEFORE calling `handle()`.
-   */
+  * Per-user in-flight nonce guard (single-process only).
+  *
+  * Prevents two concurrent requests from reading the same on-chain
+  * burnRequestNonce before either has completed, which would produce two
+  * signed UserOps with the same nonce — only one succeeds on-chain; the
+  * other leaves an orphaned pending credit and a wasted signer call.
+  *
+  * NOTE: This guard is effective only within a single Node.js process. For
+  * multi-instance deployments (k8s, PM2 cluster), enforce mutual exclusion
+  * via a distributed lock (Redis SETNX / Postgres advisory lock) keyed on
+  * `(userAddress, pointTokenAddress)` BEFORE calling `handle()`.
+  */
   inFlightNonces = /* @__PURE__ */ new Map();
   constructor(config) {
     if (!config.ledger.reservePendingCredit) {
-      throw new PTRedeemError(
-        "LEDGER_NOT_SUPPORTED",
-        "PTRedeemHandler requires a ledger that implements reservePendingCredit() (v0.3.0+)"
-      );
+      throw new PTRedeemError("LEDGER_NOT_SUPPORTED", "PTRedeemHandler requires a ledger that implements reservePendingCredit() (v0.3.0+)");
     }
     if (!config.burnerSignerWallet) {
-      throw new PTRedeemError(
-        "SIGNING_FAILED",
-        "PTRedeemHandler requires burnerSignerWallet (issuer burner signer)"
-      );
+      throw new PTRedeemError("SIGNING_FAILED", "PTRedeemHandler requires burnerSignerWallet (issuer burner signer)");
     }
     this.ledger = config.ledger;
     this.relayService = config.relayService;
@@ -2149,10 +2073,7 @@ var PTRedeemHandler = class {
     this.domainResolver = config.domainResolver;
     this.burnerSignerWallet = config.burnerSignerWallet;
     if (!config.supportedTokens) {
-      throw new PTRedeemError(
-        "UNSUPPORTED_POINT_TOKEN",
-        "PTRedeemHandler requires `supportedTokens` (issuer's allow-listed PointToken contracts)."
-      );
+      throw new PTRedeemError("UNSUPPORTED_POINT_TOKEN", "PTRedeemHandler requires `supportedTokens` (issuer's allow-listed PointToken contracts).");
     }
     this.supportedTokens = config.supportedTokens;
     if (this.burnerSignerWallet?.account?.type === "local") {
@@ -2163,10 +2084,7 @@ var PTRedeemHandler = class {
     this.now = config.now ?? (() => Date.now());
     const maxAllowedSignatureMs = this.redeemLockDurationMs - M11_SAFETY_MARGIN_MS;
     if (this.signatureDeadlineSeconds * 1e3 > maxAllowedSignatureMs) {
-      throw new PTRedeemError(
-        "INVALID_AMOUNT",
-        `PTRedeemHandler config: signatureDeadlineSeconds (${this.signatureDeadlineSeconds}s) must be at most redeemLockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (redeemLockDurationMs=${this.redeemLockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS / 1e3}s).`
-      );
+      throw new PTRedeemError("INVALID_AMOUNT", `PTRedeemHandler config: signatureDeadlineSeconds (${this.signatureDeadlineSeconds}s) must be at most redeemLockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (redeemLockDurationMs=${this.redeemLockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS / 1e3}s).`);
     }
     if (config.redemptionService) {
       this.redemptionService = config.redemptionService;
@@ -2174,46 +2092,31 @@ var PTRedeemHandler = class {
   }
   async handle(request) {
     if (getAddress7(request.authenticatedAddress) !== getAddress7(request.userAddress)) {
-      throw new PTRedeemError(
-        "UNAUTHORIZED",
-        `userAddress (${request.userAddress}) does not match authenticated session (${request.authenticatedAddress})`
-      );
+      throw new PTRedeemError("UNAUTHORIZED", `userAddress (${request.userAddress}) does not match authenticated session (${request.authenticatedAddress})`);
     }
     if (request.amount <= 0n) {
       throw new PTRedeemError("INVALID_AMOUNT", "redeem amount must be positive");
     }
     const pointTokenAddress = getAddress7(request.pointTokenAddress);
     if (!this.supportedTokens.has(pointTokenAddress)) {
-      throw new PTRedeemError(
-        "UNSUPPORTED_POINT_TOKEN",
-        `redeem: pointTokenAddress ${pointTokenAddress} is not in the issuer's supported-token allowlist. Check IssuerApiHandlers.supportedTokens and PTRedeemHandler.config.supportedTokens point at the same set.`
-      );
+      throw new PTRedeemError("UNSUPPORTED_POINT_TOKEN", `redeem: pointTokenAddress ${pointTokenAddress} is not in the issuer's supported-token allowlist. Check IssuerApiHandlers.supportedTokens and PTRedeemHandler.config.supportedTokens point at the same set.`);
     }
     if (this.redemptionService) {
       let decision;
       try {
-        decision = await this.redemptionService.evaluate(
-          request.userAddress,
-          request.amount,
-          pointTokenAddress
-        );
+        decision = await this.redemptionService.evaluate(request.userAddress, request.amount, pointTokenAddress);
       } catch (err) {
         const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
         if (code === "POLICY_PROVIDER_UNAVAILABLE") {
-          throw new PTRedeemError(
-            "REDEMPTION_POLICY_UNAVAILABLE",
-            "Redemption policy temporarily unavailable \u2014 please try again shortly."
-          );
+          throw new PTRedeemError("REDEMPTION_POLICY_UNAVAILABLE", "Redemption policy temporarily unavailable \u2014 please try again shortly.");
         }
         throw err;
       }
       if (!decision.allowed) {
         const denial = decision.denial;
-        throw new PTRedeemError(
-          "REDEMPTION_POLICY_DENIED",
-          `redemption denied: ${denial.message}`,
-          { policyDenialCode: denial.code }
-        );
+        throw new PTRedeemError("REDEMPTION_POLICY_DENIED", `redemption denied: ${denial.message}`, {
+          policyDenialCode: denial.code
+        });
       }
     }
     let burnNonce;
@@ -2222,13 +2125,12 @@ var PTRedeemHandler = class {
         address: pointTokenAddress,
         abi: POINT_TOKEN_ABI,
         functionName: "burnRequestNonces",
-        args: [request.userAddress]
+        args: [
+          request.userAddress
+        ]
       });
     } catch (err) {
-      throw new PTRedeemError(
-        "NONCE_READ_FAILED",
-        `failed to read burnRequestNonces(${request.userAddress}): ${err instanceof Error ? err.message : String(err)}`
-      );
+      throw new PTRedeemError("NONCE_READ_FAILED", `failed to read burnRequestNonces(${request.userAddress}): ${err instanceof Error ? err.message : String(err)}`);
     }
     const nonceKey = `${getAddress7(request.userAddress).toLowerCase()}:${pointTokenAddress.toLowerCase()}`;
     let userNonces = this.inFlightNonces.get(nonceKey);
@@ -2237,10 +2139,7 @@ var PTRedeemHandler = class {
       this.inFlightNonces.set(nonceKey, userNonces);
     }
     if (userNonces.has(burnNonce)) {
-      throw new PTRedeemError(
-        "NONCE_IN_FLIGHT",
-        `A burn request for nonce ${burnNonce} is already in progress for ${request.userAddress} on ${pointTokenAddress}. Retry after the current request completes.`
-      );
+      throw new PTRedeemError("NONCE_IN_FLIGHT", `A burn request for nonce ${burnNonce} is already in progress for ${request.userAddress} on ${pointTokenAddress}. Retry after the current request completes.`);
     }
     userNonces.add(burnNonce);
     try {
@@ -2254,12 +2153,8 @@ var PTRedeemHandler = class {
     const referenceMs = this.now();
     const projectedLockExpiresAtMs = referenceMs + this.redeemLockDurationMs;
     const requestedDeadlineSec = Math.floor(referenceMs / 1e3) + this.signatureDeadlineSeconds;
-    const lockBoundedDeadlineSec = Math.floor(
-      (projectedLockExpiresAtMs - M11_SAFETY_MARGIN_MS) / 1e3
-    );
-    const previewDeadline = BigInt(
-      Math.min(requestedDeadlineSec, lockBoundedDeadlineSec)
-    );
+    const lockBoundedDeadlineSec = Math.floor((projectedLockExpiresAtMs - M11_SAFETY_MARGIN_MS) / 1e3);
+    const previewDeadline = BigInt(Math.min(requestedDeadlineSec, lockBoundedDeadlineSec));
     let fee;
     if (request.feeAmount !== void 0) {
       fee = request.feeAmount > 0n ? request.feeAmount : 0n;
@@ -2285,21 +2180,11 @@ var PTRedeemHandler = class {
     }
     const feeRecipient = request.feeRecipient ?? (request.chainId !== void 0 ? getContractAddresses2(request.chainId).pafiFeeRecipient : getContractAddresses2(this.chainId).pafiFeeRecipient);
     if (fee > 0n && fee >= request.amount) {
-      throw new PTRedeemError(
-        "INVALID_AMOUNT",
-        `fee (${fee}) must be strictly less than redeem amount (${request.amount})`
-      );
+      throw new PTRedeemError("INVALID_AMOUNT", `fee (${fee}) must be strictly less than redeem amount (${request.amount})`);
     }
-    const onChainBalance = await getPointTokenBalance2(
-      this.provider,
-      pointTokenAddress,
-      request.userAddress
-    );
+    const onChainBalance = await getPointTokenBalance2(this.provider, pointTokenAddress, request.userAddress);
     if (onChainBalance < request.amount) {
-      throw new PTRedeemError(
-        "INVALID_AMOUNT",
-        `insufficient on-chain PT balance: have ${onChainBalance}, need ${request.amount}`
-      );
+      throw new PTRedeemError("INVALID_AMOUNT", `insufficient on-chain PT balance: have ${onChainBalance}, need ${request.amount}`);
     }
     const deadline = previewDeadline;
     const domainName = await this.domainResolver.resolve(pointTokenAddress);
@@ -2321,17 +2206,9 @@ var PTRedeemHandler = class {
     try {
       sponsoredSig = (await signBurnRequest(this.burnerSignerWallet, domain, sponsoredBurnRequest)).serialized;
     } catch (err) {
-      throw new PTRedeemError(
-        "SIGNING_FAILED",
-        `failed to sign sponsored BurnRequest: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    const sponsoredLockId = await this.ledger.reservePendingCredit(
-      request.userAddress,
-      sponsoredBurnAmount,
-      this.redeemLockDurationMs,
-      pointTokenAddress
-    );
+      throw new PTRedeemError("SIGNING_FAILED", `failed to sign sponsored BurnRequest: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const sponsoredLockId = await this.ledger.reservePendingCredit(request.userAddress, sponsoredBurnAmount, this.redeemLockDurationMs, pointTokenAddress);
     try {
       const sponsoredUserOp = await this.relayService.prepareBurn({
         mode: "burnWithSig",
@@ -2357,17 +2234,9 @@ var PTRedeemHandler = class {
         try {
           fallbackSig = (await signBurnRequest(this.burnerSignerWallet, domain, fallbackBurnRequest)).serialized;
         } catch (err) {
-          throw new PTRedeemError(
-            "SIGNING_FAILED",
-            `failed to sign fallback BurnRequest: ${err instanceof Error ? err.message : String(err)}`
-          );
+          throw new PTRedeemError("SIGNING_FAILED", `failed to sign fallback BurnRequest: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const fallbackLockId = await this.ledger.reservePendingCredit(
-          request.userAddress,
-          request.amount,
-          this.redeemLockDurationMs,
-          pointTokenAddress
-        );
+        const fallbackLockId = await this.ledger.reservePendingCredit(request.userAddress, request.amount, this.redeemLockDurationMs, pointTokenAddress);
         let fallbackUserOp;
         try {
           fallbackUserOp = await this.relayService.prepareBurn({
@@ -2425,15 +2294,11 @@ var PTRedeemHandler = class {
 var DEFAULT_STATUS_CONFIRMATIONS = 3;
 async function isReceiptPastConfirmations(receipt, provider, confirmations, onWarning, handlerName) {
   if (!provider) {
-    onWarning?.(
-      `${handlerName}: provider missing \u2014 cannot enforce confirmation depth; deferring receipt fallback to on-chain indexer.`
-    );
+    onWarning?.(`${handlerName}: provider missing \u2014 cannot enforce confirmation depth; deferring receipt fallback to on-chain indexer.`);
     return false;
   }
   if (!receipt.blockNumber) {
-    onWarning?.(
-      `${handlerName}: receipt has no blockNumber \u2014 cannot enforce confirmation depth; deferring to indexer.`
-    );
+    onWarning?.(`${handlerName}: receipt has no blockNumber \u2014 cannot enforce confirmation depth; deferring to indexer.`);
     return false;
   }
   const requiredConfs = BigInt(confirmations ?? DEFAULT_STATUS_CONFIRMATIONS);
@@ -2441,18 +2306,14 @@ async function isReceiptPastConfirmations(receipt, provider, confirmations, onWa
   try {
     receiptBlock = BigInt(receipt.blockNumber);
   } catch {
-    onWarning?.(
-      `${handlerName}: malformed receipt blockNumber (${receipt.blockNumber}) \u2014 deferring to indexer.`
-    );
+    onWarning?.(`${handlerName}: malformed receipt blockNumber (${receipt.blockNumber}) \u2014 deferring to indexer.`);
     return false;
   }
   let head;
   try {
     head = await provider.getBlockNumber();
   } catch (err) {
-    onWarning?.(
-      `${handlerName}: getBlockNumber failed (${err instanceof Error ? err.message : String(err)}) \u2014 deferring to indexer.`
-    );
+    onWarning?.(`${handlerName}: getBlockNumber failed (${err instanceof Error ? err.message : String(err)}) \u2014 deferring to indexer.`);
     return false;
   }
   const depth = head - receiptBlock;
@@ -2461,7 +2322,11 @@ async function isReceiptPastConfirmations(receipt, provider, confirmations, onWa
   }
   return true;
 }
-var LockNotFoundError = class extends PafiSdkError {
+__name(isReceiptPastConfirmations, "isReceiptPastConfirmations");
+var LockNotFoundError = class LockNotFoundError2 extends PafiSdkError {
+  static {
+    __name(this, "LockNotFoundError");
+  }
   code = "LOCK_NOT_FOUND";
   httpStatus = "not_found";
   constructor() {
@@ -2470,14 +2335,9 @@ var LockNotFoundError = class extends PafiSdkError {
 };
 async function handleClaimStatus(params) {
   if (!params.ledger.getMintLock) {
-    throw new Error(
-      "handleClaimStatus: ledger does not implement `getMintLock` \u2014 implement the optional method on `IPointLedger` or write a custom status handler."
-    );
-  }
-  const lock = await params.ledger.getMintLock(
-    params.lockId,
-    params.userAddress
-  );
+    throw new Error("handleClaimStatus: ledger does not implement `getMintLock` \u2014 implement the optional method on `IPointLedger` or write a custom status handler.");
+  }
+  const lock = await params.ledger.getMintLock(params.lockId, params.userAddress);
   if (!lock || lock.userAddress.toLowerCase() !== params.userAddress.toLowerCase()) {
     throw new LockNotFoundError();
   }
@@ -2485,17 +2345,9 @@ async function handleClaimStatus(params) {
   let txHash = lock.txHash ?? null;
   if (status === "PENDING" && lock.userOpHash && params.pafiBackendClient) {
     try {
-      const receipt = await params.pafiBackendClient.getUserOpReceipt(
-        lock.userOpHash
-      );
+      const receipt = await params.pafiBackendClient.getUserOpReceipt(lock.userOpHash);
       if (receipt) {
-        const passesConfirmationDepth = await isReceiptPastConfirmations(
-          receipt,
-          params.provider,
-          params.confirmations,
-          params.onWarning,
-          "handleClaimStatus"
-        );
+        const passesConfirmationDepth = await isReceiptPastConfirmations(receipt, params.provider, params.confirmations, params.onWarning, "handleClaimStatus");
         if (!passesConfirmationDepth) {
           return {
             lockId: lock.lockId,
@@ -2508,46 +2360,31 @@ async function handleClaimStatus(params) {
         }
         if (receipt.success && receipt.txHash) {
           if (!lock.tokenAddress) {
-            params.onWarning?.(
-              `handleClaimStatus: lock ${lock.lockId} has no tokenAddress; falling back to status-only flip \u2014 atomic debit+flip cannot run on a legacy single-token row. Migrate the ledger to the multi-token schema.`
-            );
+            params.onWarning?.(`handleClaimStatus: lock ${lock.lockId} has no tokenAddress; falling back to status-only flip \u2014 atomic debit+flip cannot run on a legacy single-token row. Migrate the ledger to the multi-token schema.`);
             await params.ledger.updateMintStatus(lock.lockId, "MINTED", receipt.txHash).catch((err) => {
-              params.onWarning?.(
-                `handleClaimStatus: ledger updateMintStatus failed for lock ${lock.lockId}: ${err}`
-              );
+              params.onWarning?.(`handleClaimStatus: ledger updateMintStatus failed for lock ${lock.lockId}: ${err}`);
             });
             status = "MINTED";
             txHash = receipt.txHash;
           } else {
             try {
-              await params.ledger.deductBalance(
-                lock.userAddress,
-                lock.amount,
-                receipt.txHash,
-                lock.tokenAddress
-              );
+              await params.ledger.deductBalance(lock.userAddress, lock.amount, receipt.txHash, lock.tokenAddress);
               status = "MINTED";
               txHash = receipt.txHash;
             } catch (deductErr) {
-              params.onWarning?.(
-                `handleClaimStatus: deductBalance failed for lock ${lock.lockId}: ${deductErr}`
-              );
+              params.onWarning?.(`handleClaimStatus: deductBalance failed for lock ${lock.lockId}: ${deductErr}`);
             }
           }
         } else {
           await params.ledger.updateMintStatus(lock.lockId, "FAILED", receipt.txHash).catch((err) => {
-            params.onWarning?.(
-              `handleClaimStatus: ledger updateMintStatus failed for lock ${lock.lockId}: ${err}`
-            );
+            params.onWarning?.(`handleClaimStatus: ledger updateMintStatus failed for lock ${lock.lockId}: ${err}`);
           });
           status = "FAILED";
           txHash = receipt.txHash;
         }
       }
     } catch (err) {
-      params.onWarning?.(
-        `handleClaimStatus: bundler-receipt fallback failed for lock ${lock.lockId}: ${err}`
-      );
+      params.onWarning?.(`handleClaimStatus: bundler-receipt fallback failed for lock ${lock.lockId}: ${err}`);
     }
   }
   return {
@@ -2559,16 +2396,12 @@ async function handleClaimStatus(params) {
     expiresAt: new Date(lock.expiresAt).toISOString()
   };
 }
+__name(handleClaimStatus, "handleClaimStatus");
 async function handleRedeemStatus(params) {
   if (!params.ledger.getPendingCredit) {
-    throw new Error(
-      "handleRedeemStatus: ledger does not implement `getPendingCredit` \u2014 implement the optional method on `IPointLedger` or write a custom status handler."
-    );
-  }
-  const credit = await params.ledger.getPendingCredit(
-    params.lockId,
-    params.userAddress
-  );
+    throw new Error("handleRedeemStatus: ledger does not implement `getPendingCredit` \u2014 implement the optional method on `IPointLedger` or write a custom status handler.");
+  }
+  const credit = await params.ledger.getPendingCredit(params.lockId, params.userAddress);
   if (!credit || credit.userAddress.toLowerCase() !== params.userAddress.toLowerCase()) {
     throw new LockNotFoundError();
   }
@@ -2576,33 +2409,21 @@ async function handleRedeemStatus(params) {
   let txHash = credit.txHash ?? null;
   if (status === "PENDING" && credit.userOpHash && params.pafiBackendClient) {
     try {
-      const receipt = await params.pafiBackendClient.getUserOpReceipt(
-        credit.userOpHash
-      );
+      const receipt = await params.pafiBackendClient.getUserOpReceipt(credit.userOpHash);
       if (receipt && receipt.success) {
-        const passesConfirmationDepth = await isReceiptPastConfirmations(
-          receipt,
-          params.provider,
-          params.confirmations,
-          params.onWarning,
-          "handleRedeemStatus"
-        );
+        const passesConfirmationDepth = await isReceiptPastConfirmations(receipt, params.provider, params.confirmations, params.onWarning, "handleRedeemStatus");
         if (passesConfirmationDepth) {
           status = "RESOLVED";
           txHash = receipt.txHash;
           if (params.ledger.resolveCreditByBurnTx) {
             await params.ledger.resolveCreditByBurnTx(credit.lockId, receipt.txHash).catch((err) => {
-              params.onWarning?.(
-                `handleRedeemStatus: resolveCreditByBurnTx failed for lock ${credit.lockId}: ${err}`
-              );
+              params.onWarning?.(`handleRedeemStatus: resolveCreditByBurnTx failed for lock ${credit.lockId}: ${err}`);
             });
           }
         }
       }
     } catch (err) {
-      params.onWarning?.(
-        `handleRedeemStatus: bundler-receipt fallback failed for lock ${credit.lockId}: ${err}`
-      );
+      params.onWarning?.(`handleRedeemStatus: bundler-receipt fallback failed for lock ${credit.lockId}: ${err}`);
     }
   }
   return {
@@ -2615,59 +2436,52 @@ async function handleRedeemStatus(params) {
     resolvedAt: credit.resolvedAt ? new Date(credit.resolvedAt).toISOString() : null
   };
 }
+__name(handleRedeemStatus, "handleRedeemStatus");
 
 // src/api/mobileHandlers.ts
 import { getAddress as getAddress8 } from "viem";
-import {
-  ENTRY_POINT_V08,
-  parseEip7702DelegatedAddress
-} from "@pafi-dev/core";
+import { ENTRY_POINT_V08, parseEip7702DelegatedAddress } from "@pafi-dev/core";
 
 // src/userop-store/serialize.ts
 import { serializeUserOpToJsonRpc } from "@pafi-dev/core";
 function serializeEntryToJsonRpc(entry, signature, variant = "sponsored") {
   if (variant === "fallback") {
     if (!entry.fallback) {
-      throw new Error(
-        "serializeEntryToJsonRpc: variant=fallback requested but the stored entry has no `fallback` branch \u2014 caller should resubmit with variant='sponsored' or re-prepare with a fee configured."
-      );
+      throw new Error("serializeEntryToJsonRpc: variant=fallback requested but the stored entry has no `fallback` branch \u2014 caller should resubmit with variant='sponsored' or re-prepare with a fee configured.");
     }
-    return serializeUserOpToJsonRpc(
-      {
-        sender: entry.sender,
-        nonce: BigInt(entry.nonce),
-        callData: entry.fallback.callData,
-        callGasLimit: BigInt(entry.fallback.callGasLimit),
-        verificationGasLimit: BigInt(entry.fallback.verificationGasLimit),
-        preVerificationGas: BigInt(entry.fallback.preVerificationGas),
-        maxFeePerGas: BigInt(entry.maxFeePerGas),
-        maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas)
-        // intentionally no paymaster — user pays ETH gas
-      },
-      signature
-    );
-  }
-  return serializeUserOpToJsonRpc(
-    {
+    return serializeUserOpToJsonRpc({
       sender: entry.sender,
       nonce: BigInt(entry.nonce),
-      callData: entry.callData,
-      callGasLimit: BigInt(entry.callGasLimit),
-      verificationGasLimit: BigInt(entry.verificationGasLimit),
-      preVerificationGas: BigInt(entry.preVerificationGas),
+      callData: entry.fallback.callData,
+      callGasLimit: BigInt(entry.fallback.callGasLimit),
+      verificationGasLimit: BigInt(entry.fallback.verificationGasLimit),
+      preVerificationGas: BigInt(entry.fallback.preVerificationGas),
       maxFeePerGas: BigInt(entry.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas),
-      paymaster: entry.paymaster,
-      paymasterVerificationGasLimit: entry.paymasterVerificationGasLimit != null ? BigInt(entry.paymasterVerificationGasLimit) : void 0,
-      paymasterPostOpGasLimit: entry.paymasterPostOpGasLimit != null ? BigInt(entry.paymasterPostOpGasLimit) : void 0,
-      paymasterData: entry.paymasterData
-    },
-    signature
-  );
+      maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas)
+    }, signature);
+  }
+  return serializeUserOpToJsonRpc({
+    sender: entry.sender,
+    nonce: BigInt(entry.nonce),
+    callData: entry.callData,
+    callGasLimit: BigInt(entry.callGasLimit),
+    verificationGasLimit: BigInt(entry.verificationGasLimit),
+    preVerificationGas: BigInt(entry.preVerificationGas),
+    maxFeePerGas: BigInt(entry.maxFeePerGas),
+    maxPriorityFeePerGas: BigInt(entry.maxPriorityFeePerGas),
+    paymaster: entry.paymaster,
+    paymasterVerificationGasLimit: entry.paymasterVerificationGasLimit != null ? BigInt(entry.paymasterVerificationGasLimit) : void 0,
+    paymasterPostOpGasLimit: entry.paymasterPostOpGasLimit != null ? BigInt(entry.paymasterPostOpGasLimit) : void 0,
+    paymasterData: entry.paymasterData
+  }, signature);
 }
+__name(serializeEntryToJsonRpc, "serializeEntryToJsonRpc");
 
 // src/userop-store/memoryStore.ts
 var MemoryPendingUserOpStore = class {
+  static {
+    __name(this, "MemoryPendingUserOpStore");
+  }
   entries = /* @__PURE__ */ new Map();
   now;
   constructor(now = () => Date.now()) {
@@ -2694,29 +2508,7 @@ var MemoryPendingUserOpStore = class {
 };
 
 // src/userop-store/prepareUserOp.ts
-import {
-  buildUserOpTypedData,
-  computeUserOpHash
-} from "@pafi-dev/core";
-function serializeUserOpTypedData(td) {
-  return {
-    domain: td.domain,
-    types: td.types,
-    primaryType: td.primaryType,
-    message: {
-      sender: td.message.sender,
-      nonce: `0x${td.message.nonce.toString(16)}`,
-      initCode: td.message.initCode,
-      callData: td.message.callData,
-      accountGasLimits: td.message.accountGasLimits,
-      preVerificationGas: `0x${td.message.preVerificationGas.toString(
-        16
-      )}`,
-      gasFees: td.message.gasFees,
-      paymasterAndData: td.message.paymasterAndData
-    }
-  };
-}
+import { computeUserOpHash } from "@pafi-dev/core";
 function mergePaymasterFields(userOp, paymasterFields) {
   if (!paymasterFields) return userOp;
   const merged = {
@@ -2727,36 +2519,26 @@ function mergePaymasterFields(userOp, paymasterFields) {
   }
   return merged;
 }
+__name(mergePaymasterFields, "mergePaymasterFields");
 function applyPaymasterGasEstimates(partialUserOp, paymasterFields, chainId) {
-  const userOp = mergePaymasterFields(
-    partialUserOp,
-    paymasterFields
-  );
+  const userOp = mergePaymasterFields(partialUserOp, paymasterFields);
   return {
     userOp,
-    userOpHash: computeUserOpHash(userOp, chainId),
-    typedData: serializeUserOpTypedData(buildUserOpTypedData(userOp, chainId))
+    userOpHash: computeUserOpHash(userOp, chainId)
   };
 }
+__name(applyPaymasterGasEstimates, "applyPaymasterGasEstimates");
 async function prepareMobileUserOp(params) {
-  const sponsored = applyPaymasterGasEstimates(
-    params.partialUserOp,
-    params.paymasterFields,
-    params.chainId
-  );
+  const sponsored = applyPaymasterGasEstimates(params.partialUserOp, params.paymasterFields, params.chainId);
   const { userOp, userOpHash } = sponsored;
   let fallback;
   let fallbackEntry;
   if (params.partialUserOpFallback) {
-    fallback = applyPaymasterGasEstimates(
-      {
-        ...params.partialUserOpFallback,
-        maxFeePerGas: userOp.maxFeePerGas,
-        maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
-      },
-      void 0,
-      params.chainId
-    );
+    fallback = applyPaymasterGasEstimates({
+      ...params.partialUserOpFallback,
+      maxFeePerGas: userOp.maxFeePerGas,
+      maxPriorityFeePerGas: userOp.maxPriorityFeePerGas
+    }, void 0, params.chainId);
     fallbackEntry = {
       callData: fallback.userOp.callData,
       callGasLimit: fallback.userOp.callGasLimit.toString(),
@@ -2793,23 +2575,24 @@ async function prepareMobileUserOp(params) {
     entry
   };
 }
+__name(prepareMobileUserOp, "prepareMobileUserOp");
 
 // src/pafi-backend/types.ts
 var PafiBackendError = class extends Error {
-  constructor(code, message, httpStatus, details, opts) {
-    super(message);
-    this.code = code;
-    this.httpStatus = httpStatus;
-    this.details = details;
-    this.name = "PafiBackendError";
-    if (opts?.retryAfter !== void 0) this.retryAfter = opts.retryAfter;
-    if (opts?.safeToRetry !== void 0) this.serverSafeToRetry = opts.safeToRetry;
+  static {
+    __name(this, "PafiBackendError");
   }
   code;
   httpStatus;
   details;
   retryAfter;
   serverSafeToRetry;
+  constructor(code, message, httpStatus, details, opts) {
+    super(message), this.code = code, this.httpStatus = httpStatus, this.details = details;
+    this.name = "PafiBackendError";
+    if (opts?.retryAfter !== void 0) this.retryAfter = opts.retryAfter;
+    if (opts?.safeToRetry !== void 0) this.serverSafeToRetry = opts.safeToRetry;
+  }
   get safeToRetry() {
     if (this.serverSafeToRetry !== void 0) return this.serverSafeToRetry;
     switch (this.code) {
@@ -2831,15 +2614,19 @@ var PafiBackendError = class extends Error {
 
 // src/pafi-backend/helpers.ts
 var BundlerNotConfiguredError = class extends PafiSdkError {
+  static {
+    __name(this, "BundlerNotConfiguredError");
+  }
   code = "BUNDLER_NOT_CONFIGURED";
   httpStatus = "service_unavailable";
   constructor() {
-    super(
-      "PAFI backend client not configured \u2014 set PAFI_BACKEND_URL, PAFI_ISSUER_ID, PAFI_API_KEY to enable mobile submit."
-    );
+    super("PAFI backend client not configured \u2014 set PAFI_BACKEND_URL, PAFI_ISSUER_ID, PAFI_API_KEY to enable mobile submit.");
   }
 };
 var BundlerRejectedError = class extends PafiSdkError {
+  static {
+    __name(this, "BundlerRejectedError");
+  }
   code = "BUNDLER_REJECTED";
   httpStatus = "unprocessable";
   cause;
@@ -2861,7 +2648,9 @@ async function requestPaymaster(params) {
         function: fn,
         pointToken: params.pointTokenAddress
       },
-      ...params.eip7702Auth ? { eip7702Auth: params.eip7702Auth } : {}
+      ...params.eip7702Auth ? {
+        eip7702Auth: params.eip7702Auth
+      } : {}
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -2872,6 +2661,7 @@ async function requestPaymaster(params) {
     throw err;
   }
 }
+__name(requestPaymaster, "requestPaymaster");
 function isTransientPaymasterError(code) {
   switch (code) {
     case "NETWORK_ERROR":
@@ -2884,6 +2674,7 @@ function isTransientPaymasterError(code) {
       return false;
   }
 }
+__name(isTransientPaymasterError, "isTransientPaymasterError");
 function defaultFunctionForScenario(scenario) {
   switch (scenario) {
     case "mint":
@@ -2898,6 +2689,7 @@ function defaultFunctionForScenario(scenario) {
       return scenario;
   }
 }
+__name(defaultFunctionForScenario, "defaultFunctionForScenario");
 async function relayUserOp(params) {
   if (!params.client) {
     throw new BundlerNotConfiguredError();
@@ -2908,36 +2700,43 @@ async function relayUserOp(params) {
       entryPoint: params.entryPoint,
       eip7702Auth: params.eip7702Auth
     });
-    return { userOpHash: result.userOpHash };
+    return {
+      userOpHash: result.userOpHash
+    };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new BundlerRejectedError(msg, err);
   }
 }
+__name(relayUserOp, "relayUserOp");
 
 // src/api/mobileHandlers.ts
 var PendingUserOpNotFoundError = class extends PafiSdkError {
+  static {
+    __name(this, "PendingUserOpNotFoundError");
+  }
   code = "PENDING_USEROP_NOT_FOUND";
   httpStatus = "not_found";
   constructor(lockId) {
-    super(
-      `No pending UserOp found for lockId ${lockId} \u2014 it may have expired or already been submitted.`
-    );
+    super(`No pending UserOp found for lockId ${lockId} \u2014 it may have expired or already been submitted.`);
   }
 };
 var PendingUserOpForbiddenError = class extends PafiSdkError {
+  static {
+    __name(this, "PendingUserOpForbiddenError");
+  }
   code = "PENDING_USEROP_FORBIDDEN";
   httpStatus = "forbidden";
   constructor(lockId) {
-    super(
-      `Pending UserOp ${lockId} does not belong to the authenticated user.`
-    );
+    super(`Pending UserOp ${lockId} does not belong to the authenticated user.`);
   }
 };
 async function handleMobilePrepare(params) {
   const [fees, userCode] = await Promise.all([
     params.provider.estimateFeesPerGas(),
-    params.provider.getCode({ address: params.userAddress })
+    params.provider.getCode({
+      address: params.userAddress
+    })
   ]);
   const needsDelegation = !params.eip7702Auth && parseEip7702DelegatedAddress(userCode) === null;
   const sponsoredOp = {
@@ -2971,6 +2770,7 @@ async function handleMobilePrepare(params) {
     needsDelegation
   };
 }
+__name(handleMobilePrepare, "handleMobilePrepare");
 async function handleMobileSubmit(params) {
   const entry = await params.store.get(params.lockId);
   if (!entry) {
@@ -2990,19 +2790,21 @@ async function handleMobileSubmit(params) {
   const targetLockId = variant === "fallback" && entry.fallback?.lockId ? entry.fallback.lockId : params.lockId;
   await params.bindUserOpHash(targetLockId, result.userOpHash);
   await params.store.delete(params.lockId);
-  return { userOpHash: result.userOpHash };
+  return {
+    userOpHash: result.userOpHash
+  };
 }
+__name(handleMobileSubmit, "handleMobileSubmit");
 
 // src/api/handlers/ptClaimHandler.ts
 import { getAddress as getAddress9 } from "viem";
-import {
-  POINT_TOKEN_ABI as POINT_TOKEN_ABI2,
-  decodeBatchExecuteCalls,
-  getContractAddresses as getContractAddresses3
-} from "@pafi-dev/core";
+import { POINT_TOKEN_ABI as POINT_TOKEN_ABI2, decodeKernelExecuteCalls, getContractAddresses as getContractAddresses3 } from "@pafi-dev/core";
 
 // src/issuer-state/types.ts
 var IssuerStateError = class extends PafiSdkError {
+  static {
+    __name(this, "IssuerStateError");
+  }
   httpStatus = "unprocessable";
   code;
   details;
@@ -3017,6 +2819,9 @@ var IssuerStateError = class extends PafiSdkError {
 
 // src/api/handlers/ptClaimHandler.ts
 var PTClaimError = class extends PafiSdkError {
+  static {
+    __name(this, "PTClaimError");
+  }
   httpStatus = "unprocessable";
   code;
   details;
@@ -3031,32 +2836,29 @@ function isNoWrapper2(address) {
   const lower = address.toLowerCase();
   return lower === "0x0000000000000000000000000000000000000000" || lower === "0x000000000000000000000000000000000000dead";
 }
+__name(isNoWrapper2, "isNoWrapper");
 var DEFAULT_LOCK_MS = 15 * 60 * 1e3;
 var M11_SAFETY_MARGIN_MS2 = 30 * 1e3;
 var DEFAULT_SIG_DEADLINE_SEC2 = (DEFAULT_LOCK_MS - M11_SAFETY_MARGIN_MS2) / 1e3;
 var PTClaimHandler = class {
+  static {
+    __name(this, "PTClaimHandler");
+  }
   cfg;
   inFlightNonces = /* @__PURE__ */ new Map();
   constructor(config) {
     if (!config.supportedTokens) {
-      throw new PTClaimError(
-        "UNSUPPORTED_POINT_TOKEN",
-        "PTClaimHandler requires `supportedTokens` (issuer's allow-listed PointToken contracts)."
-      );
+      throw new PTClaimError("UNSUPPORTED_POINT_TOKEN", "PTClaimHandler requires `supportedTokens` (issuer's allow-listed PointToken contracts).");
     }
     const lockDurationMs = config.lockDurationMs ?? DEFAULT_LOCK_MS;
     const signatureDeadlineSeconds = config.signatureDeadlineSeconds ?? DEFAULT_SIG_DEADLINE_SEC2;
     const maxAllowedSignatureMs = lockDurationMs - M11_SAFETY_MARGIN_MS2;
     if (signatureDeadlineSeconds * 1e3 > maxAllowedSignatureMs) {
-      throw new PTClaimError(
-        "VALIDATION_FAILED",
-        `PTClaimHandler config: signatureDeadlineSeconds (${signatureDeadlineSeconds}s) must be at most lockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (lockDurationMs=${lockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS2 / 1e3}s).`,
-        {
-          lockDurationMs,
-          signatureDeadlineSeconds,
-          maxAllowedSignatureSec: maxAllowedSignatureMs / 1e3
-        }
-      );
+      throw new PTClaimError("VALIDATION_FAILED", `PTClaimHandler config: signatureDeadlineSeconds (${signatureDeadlineSeconds}s) must be at most lockDurationMs - safety margin = ${maxAllowedSignatureMs / 1e3}s (lockDurationMs=${lockDurationMs / 1e3}s, safety=${M11_SAFETY_MARGIN_MS2 / 1e3}s).`, {
+        lockDurationMs,
+        signatureDeadlineSeconds,
+        maxAllowedSignatureSec: maxAllowedSignatureMs / 1e3
+      });
     }
     this.cfg = {
       ...config,
@@ -3067,51 +2869,39 @@ var PTClaimHandler = class {
   }
   async handle(request) {
     if (getAddress9(request.authenticatedAddress) !== getAddress9(request.userAddress)) {
-      throw new PTClaimError(
-        "VALIDATION_FAILED",
-        `userAddress (${request.userAddress}) does not match authenticated session (${request.authenticatedAddress})`
-      );
+      throw new PTClaimError("VALIDATION_FAILED", `userAddress (${request.userAddress}) does not match authenticated session (${request.authenticatedAddress})`);
     }
     if (request.amount <= 0n) {
       throw new PTClaimError("INVALID_AMOUNT", "claim amount must be positive");
     }
     const pointTokenAddress = getAddress9(request.pointTokenAddress);
     if (!this.cfg.supportedTokens.has(pointTokenAddress)) {
-      throw new PTClaimError(
-        "UNSUPPORTED_POINT_TOKEN",
-        `claim: pointTokenAddress ${pointTokenAddress} is not in the issuer's supported-token allowlist. Check IssuerApiHandlers.supportedTokens and PTClaimHandler.config.supportedTokens point at the same set.`,
-        { requested: pointTokenAddress }
-      );
+      throw new PTClaimError("UNSUPPORTED_POINT_TOKEN", `claim: pointTokenAddress ${pointTokenAddress} is not in the issuer's supported-token allowlist. Check IssuerApiHandlers.supportedTokens and PTClaimHandler.config.supportedTokens point at the same set.`, {
+        requested: pointTokenAddress
+      });
     }
     if (this.cfg.issuerStateValidator) {
       try {
-        await this.cfg.issuerStateValidator.preValidateMint(
-          request.pointTokenAddress,
-          request.amount
-        );
+        await this.cfg.issuerStateValidator.preValidateMint(request.pointTokenAddress, request.amount);
       } catch (err) {
         if (err instanceof IssuerStateError) throw err;
-        throw new PTClaimError(
-          "VALIDATION_FAILED",
-          `issuer-state pre-validate failed: ${err instanceof Error ? err.message : String(err)}`
-        );
+        throw new PTClaimError("VALIDATION_FAILED", `issuer-state pre-validate failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     const chainAddresses = getContractAddresses3(request.chainId);
-    const { batchExecutor: batchExecutorAddress } = chainAddresses;
+    const { kernel: batchExecutorAddress } = chainAddresses;
     let mintRequestNonce;
     try {
       mintRequestNonce = await this.cfg.provider.readContract({
         address: request.pointTokenAddress,
         abi: POINT_TOKEN_ABI2,
         functionName: "mintRequestNonces",
-        args: [request.userAddress]
+        args: [
+          request.userAddress
+        ]
       });
     } catch (err) {
-      throw new PTClaimError(
-        "NONCE_READ_FAILED",
-        `failed to read mintRequestNonces(${request.userAddress}): ${err instanceof Error ? err.message : String(err)}`
-      );
+      throw new PTClaimError("NONCE_READ_FAILED", `failed to read mintRequestNonces(${request.userAddress}): ${err instanceof Error ? err.message : String(err)}`);
     }
     const nonceKey = `${getAddress9(request.userAddress).toLowerCase()}:${request.pointTokenAddress.toLowerCase()}`;
     let userNonces = this.inFlightNonces.get(nonceKey);
@@ -3120,11 +2910,11 @@ var PTClaimHandler = class {
       this.inFlightNonces.set(nonceKey, userNonces);
     }
     if (userNonces.has(mintRequestNonce)) {
-      throw new PTClaimError(
-        "NONCE_IN_FLIGHT",
-        `concurrent claim for nonce ${mintRequestNonce} in progress; retry after the prior request completes`,
-        { userAddress: request.userAddress, pointToken: request.pointTokenAddress, nonce: mintRequestNonce.toString() }
-      );
+      throw new PTClaimError("NONCE_IN_FLIGHT", `concurrent claim for nonce ${mintRequestNonce} in progress; retry after the prior request completes`, {
+        userAddress: request.userAddress,
+        pointToken: request.pointTokenAddress,
+        nonce: mintRequestNonce.toString()
+      });
     }
     userNonces.add(mintRequestNonce);
     const wrapperOverride = this.cfg.mintFeeWrapperAddress;
@@ -3133,20 +2923,11 @@ var PTClaimHandler = class {
     try {
       const lockCreatedAtMs = this.cfg.now();
       const lockExpiresAtMs = lockCreatedAtMs + this.cfg.lockDurationMs;
-      const lockId = await this.cfg.ledger.lockForMinting(
-        request.userAddress,
-        request.amount,
-        this.cfg.lockDurationMs,
-        request.pointTokenAddress
-      );
+      const lockId = await this.cfg.ledger.lockForMinting(request.userAddress, request.amount, this.cfg.lockDurationMs, request.pointTokenAddress);
       try {
         const requestedDeadlineSec = Math.floor(lockCreatedAtMs / 1e3) + this.cfg.signatureDeadlineSeconds;
-        const lockBoundedDeadlineSec = Math.floor(
-          (lockExpiresAtMs - M11_SAFETY_MARGIN_MS2) / 1e3
-        );
-        const signatureDeadline = BigInt(
-          Math.min(requestedDeadlineSec, lockBoundedDeadlineSec)
-        );
+        const lockBoundedDeadlineSec = Math.floor((lockExpiresAtMs - M11_SAFETY_MARGIN_MS2) / 1e3);
+        const signatureDeadline = BigInt(Math.min(requestedDeadlineSec, lockBoundedDeadlineSec));
         const previewUserOp = this.cfg.relayService.previewMintUserOp({
           userAddress: request.userAddress,
           aaNonce: request.aaNonce,
@@ -3165,15 +2946,12 @@ var PTClaimHandler = class {
           }
         }) : 0n;
         if (feeAmount > 0n && feeAmount >= request.amount) {
-          throw new PTClaimError(
-            "INVALID_AMOUNT",
-            `fee (${feeAmount}) must be strictly less than claim amount (${request.amount})`,
-            { feeAmount: feeAmount.toString(), amount: request.amount.toString() }
-          );
+          throw new PTClaimError("INVALID_AMOUNT", `fee (${feeAmount}) must be strictly less than claim amount (${request.amount})`, {
+            feeAmount: feeAmount.toString(),
+            amount: request.amount.toString()
+          });
         }
-        const domainName = await this.cfg.domainResolver.resolve(
-          request.pointTokenAddress
-        );
+        const domainName = await this.cfg.domainResolver.resolve(request.pointTokenAddress);
         const domain = {
           name: domainName,
           chainId: request.chainId,
@@ -3203,10 +2981,7 @@ var PTClaimHandler = class {
             feeAmount
           });
         } catch (err) {
-          throw new PTClaimError(
-            "BUILD_FAILED",
-            `prepareMint failed: ${err instanceof Error ? err.message : String(err)}`
-          );
+          throw new PTClaimError("BUILD_FAILED", `prepareMint failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         let fallback;
         if (feeAmount > 0n) {
@@ -3225,14 +3000,11 @@ var PTClaimHandler = class {
               mintFeeWrapperAddress: resolvedWrapper
             });
           } catch (err) {
-            throw new PTClaimError(
-              "BUILD_FAILED",
-              `prepareMint (fallback) failed: ${err instanceof Error ? err.message : String(err)}`
-            );
+            throw new PTClaimError("BUILD_FAILED", `prepareMint (fallback) failed: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-        const calls = decodeBatchExecuteCalls(userOp.callData);
-        const callsFallback = fallback ? decodeBatchExecuteCalls(fallback.callData) : void 0;
+        const calls = decodeKernelExecuteCalls(userOp.callData);
+        const callsFallback = fallback ? decodeKernelExecuteCalls(fallback.callData) : void 0;
         return {
           userOp,
           fallback,
@@ -3256,19 +3028,11 @@ var PTClaimHandler = class {
 };
 
 // src/api/handlers/perpDepositHandler.ts
-import {
-  BROKER_HASHES,
-  ORDERLY_RELAY_ABI,
-  ORDERLY_VAULT_ABI,
-  ORDERLY_VAULT_ADDRESSES,
-  TOKEN_HASHES,
-  buildPerpDepositViaRelay,
-  computeAccountId,
-  decodeBatchExecuteCalls as decodeBatchExecuteCalls2,
-  getContractAddresses as getContractAddresses4,
-  quoteOperatorFeeUsdt
-} from "@pafi-dev/core";
+import { BROKER_HASHES, ORDERLY_RELAY_ABI, ORDERLY_VAULT_ABI, ORDERLY_VAULT_ADDRESSES, TOKEN_HASHES, buildPerpDepositViaRelay, computeAccountId, decodeKernelExecuteCalls as decodeKernelExecuteCalls2, getContractAddresses as getContractAddresses4, quoteOperatorFeeUsdt } from "@pafi-dev/core";
 var PerpDepositError = class extends PafiSdkError {
+  static {
+    __name(this, "PerpDepositError");
+  }
   httpStatus = "unprocessable";
   code;
   safeToRetry;
@@ -3280,6 +3044,9 @@ var PerpDepositError = class extends PafiSdkError {
 };
 var DEFAULT_MAX_FEE_PREMIUM_BPS = 5e3;
 var PerpDepositHandler = class {
+  static {
+    __name(this, "PerpDepositHandler");
+  }
   cfg;
   constructor(config) {
     this.cfg = {
@@ -3295,10 +3062,7 @@ var PerpDepositHandler = class {
     const tokenHash = TOKEN_HASHES.USDC;
     const vault = ORDERLY_VAULT_ADDRESSES[request.chainId];
     if (!vault) {
-      throw new PerpDepositError(
-        "PERP_DEPOSIT_UNAVAILABLE",
-        `no Orderly Vault for chainId ${request.chainId}`
-      );
+      throw new PerpDepositError("PERP_DEPOSIT_UNAVAILABLE", `no Orderly Vault for chainId ${request.chainId}`);
     }
     const { orderlyRelay: relayAddress, pafiFeeRecipient } = getContractAddresses4(request.chainId);
     const [usdcAddress, brokerAllowed] = await Promise.all([
@@ -3306,20 +3070,21 @@ var PerpDepositHandler = class {
         address: vault,
         abi: ORDERLY_VAULT_ABI,
         functionName: "getAllowedToken",
-        args: [tokenHash]
+        args: [
+          tokenHash
+        ]
       }),
       this.cfg.provider.readContract({
         address: vault,
         abi: ORDERLY_VAULT_ABI,
         functionName: "getAllowedBroker",
-        args: [brokerHash]
+        args: [
+          brokerHash
+        ]
       })
     ]);
     if (!brokerAllowed) {
-      throw new PerpDepositError(
-        "BROKER_NOT_WHITELISTED",
-        `broker "${request.brokerId}" is not whitelisted on Orderly Vault`
-      );
+      throw new PerpDepositError("BROKER_NOT_WHITELISTED", `broker "${request.brokerId}" is not whitelisted on Orderly Vault`);
     }
     const accountId = computeAccountId(request.userAddress, brokerHash);
     const requestForQuote = {
@@ -3334,7 +3099,9 @@ var PerpDepositHandler = class {
         address: relayAddress,
         abi: ORDERLY_RELAY_ABI,
         functionName: "quoteTokenFee",
-        args: [requestForQuote]
+        args: [
+          requestForQuote
+        ]
       }),
       quoteOperatorFeeUsdt({
         provider: this.cfg.provider,
@@ -3344,16 +3111,10 @@ var PerpDepositHandler = class {
       })
     ]);
     if (relayTokenFee >= request.amount) {
-      throw new PerpDepositError(
-        "RELAY_FEE_EXCEEDS_AMOUNT",
-        `Relay quoted fee ${relayTokenFee} >= deposit amount ${request.amount}`
-      );
+      throw new PerpDepositError("RELAY_FEE_EXCEEDS_AMOUNT", `Relay quoted fee ${relayTokenFee} >= deposit amount ${request.amount}`);
     }
     if (usdcGasFee > 0n && usdcGasFee >= request.amount) {
-      throw new PerpDepositError(
-        "FEE_EXCEEDS_AMOUNT",
-        `USDC gas fee ${usdcGasFee} >= deposit amount ${request.amount}`
-      );
+      throw new PerpDepositError("FEE_EXCEEDS_AMOUNT", `USDC gas fee ${usdcGasFee} >= deposit amount ${request.amount}`);
     }
     const maxFee = relayTokenFee * BigInt(1e4 + this.cfg.maxFeePremiumBps) / 10000n;
     const depositReq = {
@@ -3388,138 +3149,19 @@ var PerpDepositHandler = class {
       brokerHash,
       usdcAddress,
       relayAddress,
-      calls: decodeBatchExecuteCalls2(sponsoredOp.callData),
-      callsFallback: fallbackOp ? decodeBatchExecuteCalls2(fallbackOp.callData) : void 0
+      calls: decodeKernelExecuteCalls2(sponsoredOp.callData),
+      callsFallback: fallbackOp ? decodeKernelExecuteCalls2(fallbackOp.callData) : void 0
     };
   }
 };
 
-// src/api/delegateHandler.ts
-import {
-  ENTRY_POINT_V08 as ENTRY_POINT_V082,
-  buildDelegationUserOp,
-  buildEip7702Authorization,
-  getContractAddresses as getContractAddresses5,
-  serializeUserOpToJsonRpc as serializeUserOpToJsonRpc2
-} from "@pafi-dev/core";
-import { getAddress as getAddress10 } from "viem";
-var DEFAULT_DELEGATE_GAS = {
-  callGasLimit: 100000n,
-  verificationGasLimit: 150000n,
-  preVerificationGas: 50000n
-};
-async function handleDelegatePrepare(params) {
-  const { batchExecutor } = getContractAddresses5(params.chainId);
-  const partial = buildDelegationUserOp({
-    userAddress: params.userAddress,
-    aaNonce: params.aaNonce,
-    gasLimits: {
-      callGasLimit: params.gasLimits?.callGasLimit ?? DEFAULT_DELEGATE_GAS.callGasLimit,
-      verificationGasLimit: params.gasLimits?.verificationGasLimit ?? DEFAULT_DELEGATE_GAS.verificationGasLimit,
-      preVerificationGas: params.gasLimits?.preVerificationGas ?? DEFAULT_DELEGATE_GAS.preVerificationGas
-    }
-  });
-  const userOp = {
-    sender: partial.sender,
-    nonce: partial.nonce,
-    callData: partial.callData,
-    callGasLimit: partial.callGasLimit,
-    verificationGasLimit: partial.verificationGasLimit,
-    preVerificationGas: partial.preVerificationGas,
-    maxFeePerGas: params.fees.maxFeePerGas ?? 0n,
-    maxPriorityFeePerGas: params.fees.maxPriorityFeePerGas ?? 0n
-  };
-  const authorization = buildEip7702Authorization({
-    chainId: params.chainId,
-    address: batchExecutor,
-    nonce: params.delegationNonce,
-    authSig: params.authSig
-  });
-  const paymasterFields = await requestPaymaster({
-    client: params.pafiBackendClient,
-    chainId: params.chainId,
-    scenario: "delegate",
-    userOp,
-    pointTokenAddress: batchExecutor,
-    eip7702Auth: authorization,
-    onWarning: params.onWarning
-  });
-  const prepared = applyPaymasterGasEstimates(
-    userOp,
-    paymasterFields,
-    params.chainId
-  );
-  const merged = prepared.userOp;
-  const userOpHash = prepared.userOpHash;
-  await params.store.save(
-    params.lockId,
-    {
-      sender: merged.sender,
-      nonce: merged.nonce.toString(10),
-      callData: merged.callData,
-      callGasLimit: merged.callGasLimit.toString(10),
-      verificationGasLimit: merged.verificationGasLimit.toString(10),
-      preVerificationGas: merged.preVerificationGas.toString(10),
-      maxFeePerGas: merged.maxFeePerGas.toString(10),
-      maxPriorityFeePerGas: merged.maxPriorityFeePerGas.toString(10),
-      ...merged.paymaster ? { paymaster: merged.paymaster } : {},
-      ...merged.paymasterVerificationGasLimit ? {
-        paymasterVerificationGasLimit: merged.paymasterVerificationGasLimit.toString(10)
-      } : {},
-      ...merged.paymasterPostOpGasLimit ? {
-        paymasterPostOpGasLimit: merged.paymasterPostOpGasLimit.toString(10)
-      } : {},
-      ...merged.paymasterData ? { paymasterData: merged.paymasterData } : {},
-      chainId: params.chainId,
-      userOpHash,
-      eip7702Auth: authorization
-    },
-    params.ttlSeconds
-  );
-  return {
-    lockId: params.lockId,
-    userOpHash,
-    typedData: prepared.typedData,
-    expiresInSeconds: params.ttlSeconds,
-    isSponsored: !!paymasterFields
-  };
-}
-async function handleDelegateSubmit(params) {
-  const entry = await params.store.get(params.lockId);
-  if (!entry) {
-    throw new PendingUserOpNotFoundError(params.lockId);
-  }
-  if (getAddress10(entry.sender) !== getAddress10(params.authenticatedAddress)) {
-    throw new PendingUserOpForbiddenError(params.lockId);
-  }
-  if (!entry.eip7702Auth) {
-    throw new Error(
-      `delegate entry ${params.lockId} missing eip7702Auth \u2014 prepare step did not run correctly`
-    );
-  }
-  const userOpJson = serializeEntryToJsonRpc(entry, params.userOpSig, "sponsored");
-  const result = await relayUserOp({
-    client: params.pafiBackendClient,
-    userOp: userOpJson,
-    entryPoint: params.entryPoint ?? ENTRY_POINT_V082,
-    eip7702Auth: entry.eip7702Auth
-  });
-  await params.store.delete(params.lockId);
-  return { userOpHash: result.userOpHash };
-}
-
 // src/api/issuerApiAdapter.ts
-import { randomUUID } from "crypto";
-import { getAddress as getAddress11 } from "viem";
-import {
-  buildAndSignSponsorAuth,
-  decodeBatchExecuteCalls as decodeBatchExecuteCalls3,
-  encodeBatchExecute,
-  ENTRY_POINT_V08 as ENTRY_POINT_V083,
-  getContractAddresses as getContractAddresses6,
-  parseEip7702DelegatedAddress as parseEip7702DelegatedAddress2
-} from "@pafi-dev/core";
+import { getAddress as getAddress10 } from "viem";
+import { buildAndSignSponsorAuth, decodeKernelExecuteCalls as decodeKernelExecuteCalls3 } from "@pafi-dev/core";
 var AdapterMisconfiguredError = class extends Error {
+  static {
+    __name(this, "AdapterMisconfiguredError");
+  }
   code = "ADAPTER_MISCONFIGURED";
   constructor(message) {
     super(message);
@@ -3527,35 +3169,28 @@ var AdapterMisconfiguredError = class extends Error {
   }
 };
 var IssuerApiAdapter = class {
+  static {
+    __name(this, "IssuerApiAdapter");
+  }
   cfg;
   constructor(config) {
     if (config.ptClaimHandler) {
       if (typeof config.ledger.bindMintUserOpHash !== "function") {
-        throw new AdapterMisconfiguredError(
-          "ledger.bindMintUserOpHash is required when ptClaimHandler is wired (mobile claim flow). Implement it on your IPointLedger or omit ptClaimHandler from IssuerApiAdapter config."
-        );
+        throw new AdapterMisconfiguredError("ledger.bindMintUserOpHash is required when ptClaimHandler is wired (mobile claim flow). Implement it on your IPointLedger or omit ptClaimHandler from IssuerApiAdapter config.");
       }
       if (typeof config.ledger.getMintLock !== "function") {
-        throw new AdapterMisconfiguredError(
-          "ledger.getMintLock is required when ptClaimHandler is wired \u2014 claimStatus uses it to look up the lock."
-        );
+        throw new AdapterMisconfiguredError("ledger.getMintLock is required when ptClaimHandler is wired \u2014 claimStatus uses it to look up the lock.");
       }
     }
     if (config.ptRedeemHandler) {
       if (typeof config.ledger.reservePendingCredit !== "function") {
-        throw new AdapterMisconfiguredError(
-          "ledger.reservePendingCredit is required when ptRedeemHandler is wired (burn/redeem reverse flow). PTRedeemHandler also enforces this at construction; see ledger/types.ts comments."
-        );
+        throw new AdapterMisconfiguredError("ledger.reservePendingCredit is required when ptRedeemHandler is wired (burn/redeem reverse flow). PTRedeemHandler also enforces this at construction; see ledger/types.ts comments.");
       }
       if (typeof config.ledger.bindCreditUserOpHash !== "function") {
-        throw new AdapterMisconfiguredError(
-          "ledger.bindCreditUserOpHash is required when ptRedeemHandler is wired (mobile redeem flow)."
-        );
+        throw new AdapterMisconfiguredError("ledger.bindCreditUserOpHash is required when ptRedeemHandler is wired (mobile redeem flow).");
       }
       if (typeof config.ledger.getPendingCredit !== "function") {
-        throw new AdapterMisconfiguredError(
-          "ledger.getPendingCredit is required when ptRedeemHandler is wired \u2014 redeemStatus uses it to look up the credit."
-        );
+        throw new AdapterMisconfiguredError("ledger.getPendingCredit is required when ptRedeemHandler is wired \u2014 redeemStatus uses it to look up the credit.");
       }
     }
     this.cfg = config;
@@ -3570,24 +3205,25 @@ var IssuerApiAdapter = class {
   }
   async gasFee() {
     const result = await this.cfg.issuerService.api.handleGasFee();
-    return { gasFeeUsdt: result.gasFeeUsdt.toString() };
+    return {
+      gasFeeUsdt: result.gasFeeUsdt.toString()
+    };
   }
   async pools(authenticatedAddress, chainId, pointTokenAddress) {
-    const result = await this.cfg.issuerService.api.handlePools(
-      authenticatedAddress,
-      { chainId, pointTokenAddress: getAddress11(pointTokenAddress) }
-    );
-    return { pools: result.pools };
+    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: getAddress11(userAddress),
-        pointTokenAddress: getAddress11(pointTokenAddress)
-      }
-    );
+    const result = await this.cfg.issuerService.api.handleUser(authenticatedAddress, {
+      chainId,
+      userAddress: getAddress10(userAddress),
+      pointTokenAddress: getAddress10(pointTokenAddress)
+    });
     return {
       offChainBalance: result.offChainBalance.toString(),
       onChainBalance: result.onChainBalance.toString(),
@@ -3600,12 +3236,8 @@ var IssuerApiAdapter = class {
   // directly. Issuer SDK doesn't ship swap/quote anymore.
   // ------------------------------ Action endpoints -------------------------
   async claim(input) {
-    const ptClaimHandler = this.assertHandler(
-      this.cfg.ptClaimHandler,
-      "ptClaimHandler",
-      "claim"
-    );
-    const pointTokenAddress = getAddress11(input.pointTokenAddress);
+    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,
@@ -3614,12 +3246,7 @@ var IssuerApiAdapter = class {
       chainId: input.chainId,
       aaNonce: input.aaNonce
     });
-    const sponsorAuth = await this.buildSponsorAuth(
-      input.authenticatedAddress,
-      result.userOp.callData,
-      input.chainId,
-      "mint"
-    );
+    const sponsorAuth = await this.buildSponsorAuth(input.authenticatedAddress, result.userOp.callData, input.chainId, "mint");
     return {
       calls: result.calls,
       callsFallback: result.callsFallback,
@@ -3631,7 +3258,7 @@ var IssuerApiAdapter = class {
   }
   async redeem(input) {
     this.assertRedeemHandler();
-    const pointTokenAddress = getAddress11(input.pointTokenAddress);
+    const pointTokenAddress = getAddress10(input.pointTokenAddress);
     const response = await this.cfg.ptRedeemHandler.handle({
       userAddress: input.authenticatedAddress,
       authenticatedAddress: input.authenticatedAddress,
@@ -3640,15 +3267,10 @@ var IssuerApiAdapter = class {
       aaNonce: input.aaNonce,
       chainId: input.chainId
     });
-    const sponsorAuth = await this.buildSponsorAuth(
-      input.authenticatedAddress,
-      response.userOp.callData,
-      input.chainId,
-      "burn"
-    );
+    const sponsorAuth = await this.buildSponsorAuth(input.authenticatedAddress, response.userOp.callData, input.chainId, "burn");
     return {
-      calls: decodeBatchExecuteCalls3(response.userOp.callData),
-      callsFallback: response.fallback ? decodeBatchExecuteCalls3(response.fallback.userOp.callData) : void 0,
+      calls: decodeKernelExecuteCalls3(response.userOp.callData),
+      callsFallback: response.fallback ? decodeKernelExecuteCalls3(response.fallback.userOp.callData) : void 0,
       feeAmount: response.feeAmount.toString(),
       lockId: response.lockId,
       lockIdFallback: response.fallback?.lockId,
@@ -3662,11 +3284,7 @@ var IssuerApiAdapter = class {
   // swap() removed (2026-04-27) — moved to @pafi-dev/trading.
   // PAFI's web FE calls TradingHandlers.handleSwap directly.
   async perpDeposit(input) {
-    const perpHandler = this.assertHandler(
-      this.cfg.perpHandler,
-      "perpHandler",
-      "perpDeposit"
-    );
+    const perpHandler = this.assertHandler(this.cfg.perpHandler, "perpHandler", "perpDeposit");
     const result = await perpHandler.handle({
       userAddress: input.authenticatedAddress,
       chainId: input.chainId,
@@ -3674,12 +3292,7 @@ var IssuerApiAdapter = class {
       brokerId: input.brokerId,
       aaNonce: input.aaNonce
     });
-    const sponsorAuth = await this.buildSponsorAuth(
-      input.authenticatedAddress,
-      result.userOp.callData,
-      input.chainId,
-      "perp-deposit"
-    );
+    const sponsorAuth = await this.buildSponsorAuth(input.authenticatedAddress, result.userOp.callData, input.chainId, "perp-deposit");
     return {
       calls: result.calls,
       callsFallback: result.callsFallback,
@@ -3696,12 +3309,8 @@ var IssuerApiAdapter = class {
   }
   // ------------------------------ Mobile endpoints -------------------------
   async claimPrepare(input) {
-    const ptClaimHandler = this.assertHandler(
-      this.cfg.ptClaimHandler,
-      "ptClaimHandler",
-      "claimPrepare"
-    );
-    const pointTokenAddress = getAddress11(input.pointTokenAddress);
+    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,
@@ -3710,23 +3319,11 @@ var IssuerApiAdapter = class {
       chainId: input.chainId,
       aaNonce: input.aaNonce
     });
-    const prepared = await this.runMobilePrepare(
-      input.authenticatedAddress,
-      input.chainId,
-      claimResult.lockId,
-      claimResult.userOp,
-      claimResult.fallback,
-      "mint",
-      pointTokenAddress,
-      claimResult.expiresInSeconds,
-      input.eip7702Auth
-    );
+    const prepared = await this.runMobilePrepare(input.authenticatedAddress, input.chainId, claimResult.lockId, claimResult.userOp, claimResult.fallback, "mint", pointTokenAddress, claimResult.expiresInSeconds, input.eip7702Auth);
     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,
@@ -3741,13 +3338,13 @@ var IssuerApiAdapter = class {
       signature: input.signature,
       variant: input.variant,
       store: this.cfg.pendingUserOpStore,
-      bindUserOpHash: (lockId, hash) => this.cfg.ledger.bindMintUserOpHash(lockId, hash),
+      bindUserOpHash: /* @__PURE__ */ __name((lockId, hash) => this.cfg.ledger.bindMintUserOpHash(lockId, hash), "bindUserOpHash"),
       pafiBackendClient: this.cfg.pafiBackendClient
     });
   }
   async redeemPrepare(input) {
     this.assertRedeemHandler();
-    const pointTokenAddress = getAddress11(input.pointTokenAddress);
+    const pointTokenAddress = getAddress10(input.pointTokenAddress);
     const redeemResponse = await this.cfg.ptRedeemHandler.handle({
       userAddress: input.authenticatedAddress,
       authenticatedAddress: input.authenticatedAddress,
@@ -3756,25 +3353,12 @@ var IssuerApiAdapter = class {
       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,
-      input.eip7702Auth,
-      redeemResponse.fallback?.lockId
-    );
+    const prepared = await this.runMobilePrepare(input.authenticatedAddress, input.chainId, redeemResponse.lockId, redeemResponse.userOp, redeemResponse.fallback?.userOp, "burn", pointTokenAddress, redeemResponse.expiresInSeconds, input.eip7702Auth, redeemResponse.fallback?.lockId);
     return {
       lockId: redeemResponse.lockId,
       lockIdFallback: redeemResponse.fallback?.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(),
@@ -3791,7 +3375,7 @@ var IssuerApiAdapter = class {
       signature: input.signature,
       variant: input.variant,
       store: this.cfg.pendingUserOpStore,
-      bindUserOpHash: (lockId, hash) => this.cfg.ledger.bindCreditUserOpHash(lockId, hash),
+      bindUserOpHash: /* @__PURE__ */ __name((lockId, hash) => this.cfg.ledger.bindCreditUserOpHash(lockId, hash), "bindUserOpHash"),
       pafiBackendClient: this.cfg.pafiBackendClient
     });
   }
@@ -3815,83 +3399,15 @@ var IssuerApiAdapter = class {
       onWarning: this.cfg.onWarning
     });
   }
-  // ------------------------------ Delegate endpoints -----------------------
-  async delegateStatus(authenticatedAddress, chainId) {
-    const { batchExecutor } = getContractAddresses6(chainId);
-    const [code, nonce] = await Promise.all([
-      this.cfg.provider.getCode({ address: authenticatedAddress }),
-      this.cfg.provider.getTransactionCount({
-        address: authenticatedAddress,
-        blockTag: "pending"
-      })
-    ]);
-    return {
-      isDelegated: parseEip7702DelegatedAddress2(code) !== null,
-      batchExecutorAddress: batchExecutor,
-      delegationNonce: nonce.toString(),
-      chainId
-    };
-  }
-  /**
-   * Build the delegation-anchor UserOp + obtain paymaster sponsorship
-   * + persist as a pending entry. Mobile must:
-   *
-   *   1. Sign EIP-7702 authorization LOCALLY (Privy `signAuthorization`
-   *      with `{contractAddress: batchExecutorAddress, chainId,
-   *      nonce: delegationNonce}`) → 65-byte authSig hex.
-   *   2. POST `/delegate/prepare` with `{ chainId, delegationNonce,
-   *      authSig }` → this method.
-   *   3. Sign returned `userOpHash` LOCALLY (`signTypedData(typedData)`).
-   *   4. POST `/delegate/submit` with `{ lockId, userOpSig }`.
-   *
-   * v0.7.7 — replaces single-shot delegateSubmit that tried to relay
-   * a UserOp with empty `signature: "0x"` (Simple7702Account's
-   * validateUserOp reverts `ECDSAInvalidSignatureLength` 0xfce698f7).
-   */
-  async delegatePrepare(authenticatedAddress, input) {
-    const { batchExecutor } = getContractAddresses6(input.chainId);
-    const fees = await this.cfg.provider.estimateFeesPerGas();
-    const lockId = randomUUID();
-    const result = await handleDelegatePrepare({
-      userAddress: authenticatedAddress,
-      chainId: input.chainId,
-      delegationNonce: input.delegationNonce,
-      aaNonce: input.aaNonce,
-      authSig: input.authSig,
-      fees,
-      lockId,
-      store: this.cfg.pendingUserOpStore,
-      ttlSeconds: 15 * 60,
-      // 15min — match claim/redeem mobile lock duration
-      pafiBackendClient: this.cfg.pafiBackendClient,
-      onWarning: this.cfg.onWarning
-    });
-    return {
-      lockId: result.lockId,
-      userOpHash: result.userOpHash,
-      typedData: result.typedData,
-      expiresInSeconds: result.expiresInSeconds,
-      isSponsored: result.isSponsored,
-      delegationNonce: input.delegationNonce.toString(),
-      batchExecutorAddress: batchExecutor,
-      chainId: input.chainId
-    };
-  }
-  async delegateSubmit(input) {
-    const result = await handleDelegateSubmit({
-      lockId: input.lockId,
-      authenticatedAddress: input.authenticatedAddress,
-      userOpSig: input.userOpSig,
-      store: this.cfg.pendingUserOpStore,
-      pafiBackendClient: this.cfg.pafiBackendClient
-    });
-    return { userOpHash: result.userOpHash };
-  }
+  // Delegate endpoints removed — folded-in delegation (via
+  // `eip7702Auth` on claim/redeem prepare) is now the only path. The
+  // bundler applies SetCode + handleOps in one tx, so there is no
+  // separate `/delegate/*` flow. See `handleMobilePrepare`.
   // ------------------------------ Internal helpers -------------------------
   /**
-   * Build + sign a SponsorAuth payload. Returns `undefined` when no
-   * issuer id is configured, so the controller can skip the field.
-   */
+  * 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({
@@ -3923,22 +3439,18 @@ var IssuerApiAdapter = class {
   }
   assertRedeemHandler() {
     if (!this.cfg.ptRedeemHandler) {
-      throw new Error(
-        "PTRedeemHandler not wired \u2014 IssuerApiAdapter.redeem* require a configured 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).
-   */
+  * 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}.`
-      );
+      throw new Error(`${fieldName} not wired \u2014 IssuerApiAdapter.${methodName}() requires a configured ${fieldName}.`);
     }
     return handler;
   }
@@ -3971,9 +3483,7 @@ function createSubgraphPoolsProvider(config = {}) {
     }
   } catch (err) {
     if (err instanceof TypeError) {
-      throw new Error(
-        `subgraphPoolsProvider: invalid subgraphUrl: ${subgraphUrl}`
-      );
+      throw new Error(`subgraphPoolsProvider: invalid subgraphUrl: ${subgraphUrl}`);
     }
     throw err;
   }
@@ -3983,64 +3493,61 @@ function createSubgraphPoolsProvider(config = {}) {
   const onError = config.onError;
   const cache = /* @__PURE__ */ new Map();
   if (!fetchImpl) {
-    throw new Error(
-      "createSubgraphPoolsProvider: no fetch implementation available \u2014 pass `fetchImpl` or run on Node 18+"
-    );
+    throw new Error("createSubgraphPoolsProvider: no fetch implementation available \u2014 pass `fetchImpl` or run on Node 18+");
   }
-  const reportError = (err) => {
+  const reportError = /* @__PURE__ */ __name((err) => {
     if (!onError) return;
     try {
       onError(err);
     } catch {
     }
-  };
+  }, "reportError");
   return async (request) => {
     const cacheKey = `${request.chainId}:${request.pointTokenAddress.toLowerCase()}`;
     if (cacheTtl > 0) {
       const cached = cache.get(cacheKey);
       if (cached && cached.expiresAt > now()) {
-        return { pools: cached.pools };
+        return {
+          pools: cached.pools
+        };
       }
     }
-    const pools = await fetchPoolsFromSubgraph(
-      fetchImpl,
-      subgraphUrl,
-      request.pointTokenAddress,
-      reportError
-    );
+    const pools = await fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, request.pointTokenAddress, reportError);
     if (cacheTtl > 0) {
       cache.set(cacheKey, {
         expiresAt: now() + cacheTtl,
         pools
       });
     }
-    return { pools };
+    return {
+      pools
+    };
   };
 }
+__name(createSubgraphPoolsProvider, "createSubgraphPoolsProvider");
 async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress, reportError) {
   let response;
   try {
     response = await fetchImpl(subgraphUrl, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: {
+        "Content-Type": "application/json"
+      },
       body: JSON.stringify({
         query: POOL_QUERY,
-        variables: { id: pointTokenAddress.toLowerCase() }
+        variables: {
+          id: pointTokenAddress.toLowerCase()
+        }
       })
     });
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
-    console.warn(
-      "[subgraphPoolsProvider] subgraph unreachable:",
-      error.message
-    );
+    console.warn("[subgraphPoolsProvider] subgraph unreachable:", error.message);
     reportError(error);
     return [];
   }
   if (!response.ok) {
-    const error = new Error(
-      `subgraph returned HTTP ${response.status}`
-    );
+    const error = new Error(`subgraph returned HTTP ${response.status}`);
     console.warn(`[subgraphPoolsProvider] ${error.message}`);
     reportError(error);
     return [];
@@ -4050,10 +3557,7 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress,
     json = await response.json();
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
-    console.warn(
-      "[subgraphPoolsProvider] subgraph returned non-JSON:",
-      error.message
-    );
+    console.warn("[subgraphPoolsProvider] subgraph returned non-JSON:", error.message);
     reportError(error);
     return [];
   }
@@ -4069,36 +3573,39 @@ async function fetchPoolsFromSubgraph(fetchImpl, subgraphUrl, pointTokenAddress,
   }
   const { pool } = token;
   if (!isAddress(pool.token0.id) || !isAddress(pool.token1.id)) {
-    const error = new Error(
-      "[PAFI] SubgraphPoolsProvider: invalid token address in response"
-    );
+    const error = new Error("[PAFI] SubgraphPoolsProvider: invalid token address in response");
     console.error(error.message, "\u2014 skipping pool");
     reportError(error);
     return [];
   }
   const feeNum = Number(pool.feeTier);
   if (!Number.isInteger(feeNum) || feeNum < 0 || feeNum >= MAX_REASONABLE_FEE_TIER) {
-    const error = new Error(
-      `[PAFI] SubgraphPoolsProvider: invalid feeTier value: ${pool.feeTier}`
-    );
+    const error = new Error(`[PAFI] SubgraphPoolsProvider: invalid feeTier value: ${pool.feeTier}`);
     console.error(error.message, "\u2014 skipping pool");
     reportError(error);
     return [];
   }
-  const [token0, token1] = sortTokens(
-    pool.token0.id,
-    pool.token1.id
-  );
+  const [token0, token1] = sortTokens(pool.token0.id, pool.token1.id);
   const poolKey = {
     token0,
     token1,
     fee: feeNum
   };
-  return [poolKey];
+  return [
+    poolKey
+  ];
 }
+__name(fetchPoolsFromSubgraph, "fetchPoolsFromSubgraph");
 function sortTokens(a, b) {
-  return a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a];
+  return a.toLowerCase() < b.toLowerCase() ? [
+    a,
+    b
+  ] : [
+    b,
+    a
+  ];
 }
+__name(sortTokens, "sortTokens");
 
 // src/pools/subgraphNativeUsdtQuoter.ts
 var DEFAULT_CACHE_TTL_MS2 = 3e4;
@@ -4121,9 +3628,7 @@ function createSubgraphNativeUsdtQuoter(config = {}) {
     }
   } catch (err) {
     if (err instanceof TypeError) {
-      throw new Error(
-        `createSubgraphNativeUsdtQuoter: invalid subgraphUrl: ${subgraphUrl}`
-      );
+      throw new Error(`createSubgraphNativeUsdtQuoter: invalid subgraphUrl: ${subgraphUrl}`);
     }
     throw err;
   }
@@ -4134,23 +3639,15 @@ function createSubgraphNativeUsdtQuoter(config = {}) {
   const fetchImpl = config.fetchImpl ?? globalThis.fetch;
   const now = config.now ?? (() => Date.now());
   if (!fetchImpl) {
-    throw new Error(
-      "createSubgraphNativeUsdtQuoter: no fetch implementation available \u2014 pass `fetchImpl` or run on Node 18+"
-    );
+    throw new Error("createSubgraphNativeUsdtQuoter: no fetch implementation available \u2014 pass `fetchImpl` or run on Node 18+");
   }
   let cached;
   async function getUsdtPerNative() {
     if (cacheTtl > 0 && cached && cached.expiresAt > now()) {
       return cached.usdtPerNative;
     }
-    const price = await fetchEthPriceFromSubgraph(
-      fetchImpl,
-      subgraphUrl
-    );
-    const usdtPerNative = toUsdtPerNative(
-      price ?? fallbackPrice,
-      usdtDecimals
-    );
+    const price = await fetchEthPriceFromSubgraph(fetchImpl, subgraphUrl);
+    const usdtPerNative = toUsdtPerNative(price ?? fallbackPrice, usdtDecimals);
     if (cacheTtl > 0) {
       cached = {
         usdtPerNative,
@@ -4159,66 +3656,62 @@ function createSubgraphNativeUsdtQuoter(config = {}) {
     }
     return usdtPerNative;
   }
+  __name(getUsdtPerNative, "getUsdtPerNative");
   return async (amountNative) => {
     if (amountNative === 0n) return 0n;
     const usdtPerNative = await getUsdtPerNative();
     return amountNative * usdtPerNative / 10n ** BigInt(nativeDecimals);
   };
 }
+__name(createSubgraphNativeUsdtQuoter, "createSubgraphNativeUsdtQuoter");
 async function fetchEthPriceFromSubgraph(fetchImpl, subgraphUrl) {
   let response;
   try {
     response = await fetchImpl(subgraphUrl, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ query: PRICE_QUERY })
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: PRICE_QUERY
+      })
     });
   } catch (err) {
-    console.warn(
-      "[subgraphNativeUsdtQuoter] subgraph unreachable:",
-      err.message
-    );
+    console.warn("[subgraphNativeUsdtQuoter] subgraph unreachable:", err.message);
     return null;
   }
   if (!response.ok) {
-    console.warn(
-      `[subgraphNativeUsdtQuoter] subgraph returned ${response.status}`
-    );
+    console.warn(`[subgraphNativeUsdtQuoter] subgraph returned ${response.status}`);
     return null;
   }
   const json = await response.json();
   if (json.errors && json.errors.length > 0) {
-    console.warn(
-      "[subgraphNativeUsdtQuoter] subgraph errors:",
-      json.errors.map((e) => e.message).join("; ")
-    );
+    console.warn("[subgraphNativeUsdtQuoter] subgraph errors:", json.errors.map((e) => e.message).join("; "));
     return null;
   }
   const raw = json.data?.bundle?.ethPriceUSD;
   if (!raw) return null;
   const parsed = Number(raw);
   if (!Number.isFinite(parsed) || parsed <= 0) {
-    console.warn(
-      `[subgraphNativeUsdtQuoter] invalid ethPriceUSD from subgraph: ${raw}`
-    );
+    console.warn(`[subgraphNativeUsdtQuoter] invalid ethPriceUSD from subgraph: ${raw}`);
     return null;
   }
   const MIN_REASONABLE_ETH_PRICE = 100;
   const MAX_REASONABLE_ETH_PRICE = 1e5;
   if (parsed < MIN_REASONABLE_ETH_PRICE || parsed > MAX_REASONABLE_ETH_PRICE) {
-    console.warn(
-      `[PAFI] SubgraphNativeUsdtQuoter: ETH/USD price ${parsed} is outside reasonable range. Using fallback.`
-    );
+    console.warn(`[PAFI] SubgraphNativeUsdtQuoter: ETH/USD price ${parsed} is outside reasonable range. Using fallback.`);
     return null;
   }
   return parsed;
 }
+__name(fetchEthPriceFromSubgraph, "fetchEthPriceFromSubgraph");
 function toUsdtPerNative(priceFloat, usdtDecimals) {
   const fixed = priceFloat.toFixed(usdtDecimals);
   const [whole, fraction = ""] = fixed.split(".");
   const padded = (fraction + "0".repeat(usdtDecimals)).slice(0, usdtDecimals);
   return BigInt(whole + padded);
 }
+__name(toUsdtPerNative, "toUsdtPerNative");
 
 // src/pools/nativePtQuoter.ts
 import { parseAbi } from "viem";
@@ -4239,18 +3732,7 @@ var POOL_PRICE_QUERY = `
   }
 `;
 function createNativePtQuoter(config) {
-  const {
-    provider,
-    pointTokenAddress,
-    chainlinkFeedAddress = "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
-    subgraphUrl = PAFI_SUBGRAPH_URL,
-    cacheTtlMs = 3e4,
-    fallbackEthPriceUsd = 3e3,
-    fallbackPtPriceUsdt = 0.1,
-    failClosed = false,
-    fetchImpl = globalThis.fetch,
-    now = () => Date.now()
-  } = config;
+  const { provider, pointTokenAddress, chainlinkFeedAddress = "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70", subgraphUrl = PAFI_SUBGRAPH_URL, cacheTtlMs = 3e4, fallbackEthPriceUsd = 3e3, fallbackPtPriceUsdt = 0.1, failClosed = false, fetchImpl = globalThis.fetch, now = /* @__PURE__ */ __name(() => Date.now(), "now") } = config;
   let ethPriceCache;
   let ptPriceCache;
   async function getEthPrice8dec() {
@@ -4269,28 +3751,34 @@ function createNativePtQuoter(config) {
       if (ageS > CHAINLINK_MAX_AGE_S) {
         throw new Error(`Chainlink: price stale by ${ageS}s`);
       }
-      ethPriceCache = { value: answer, expiresAt: ts + cacheTtlMs };
+      ethPriceCache = {
+        value: answer,
+        expiresAt: ts + cacheTtlMs
+      };
       return answer;
     } catch (err) {
       if (failClosed) {
-        throw new Error(
-          `[nativePtQuoter] Chainlink unavailable in fail-closed mode: ${err.message}`
-        );
+        throw new Error(`[nativePtQuoter] Chainlink unavailable in fail-closed mode: ${err.message}`);
       }
       console.warn("[nativePtQuoter] Chainlink unavailable, using fallback:", err.message);
       return BigInt(Math.round(fallbackEthPriceUsd * 1e8));
     }
   }
+  __name(getEthPrice8dec, "getEthPrice8dec");
   async function getPtPerUsdt18dec() {
     const ts = now();
     if (ptPriceCache && ptPriceCache.expiresAt > ts) return ptPriceCache.value;
     try {
       const response = await fetchImpl(subgraphUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json"
+        },
         body: JSON.stringify({
           query: POOL_PRICE_QUERY,
-          variables: { id: pointTokenAddress.toLowerCase() }
+          variables: {
+            id: pointTokenAddress.toLowerCase()
+          }
         })
       });
       if (!response.ok) throw new Error(`subgraph HTTP ${response.status}`);
@@ -4306,19 +3794,21 @@ function createNativePtQuoter(config) {
       const raw = parseBigDecimalTo18(ptPerUsdtStr);
       if (raw === 0n) throw new Error(`pool price parsed to zero: ${ptPerUsdtStr}`);
       const value = 10n ** 24n / raw;
-      ptPriceCache = { value, expiresAt: ts + cacheTtlMs };
+      ptPriceCache = {
+        value,
+        expiresAt: ts + cacheTtlMs
+      };
       return value;
     } catch (err) {
       if (failClosed) {
-        throw new Error(
-          `[nativePtQuoter] subgraph miss for ${pointTokenAddress} in fail-closed mode: ${err.message}`
-        );
+        throw new Error(`[nativePtQuoter] subgraph miss for ${pointTokenAddress} in fail-closed mode: ${err.message}`);
       }
       console.warn("[nativePtQuoter] subgraph unavailable, using fallback:", err.message);
       const ptPerUsdtHuman = 1 / fallbackPtPriceUsdt;
       return parseBigDecimalTo18(ptPerUsdtHuman.toFixed(18));
     }
   }
+  __name(getPtPerUsdt18dec, "getPtPerUsdt18dec");
   return async (amountNative) => {
     if (amountNative === 0n) return 0n;
     const [ethPrice8dec, ptPerUsdt18dec] = await Promise.all([
@@ -4328,12 +3818,14 @@ function createNativePtQuoter(config) {
     return amountNative * ethPrice8dec * ptPerUsdt18dec / 10n ** 26n;
   };
 }
+__name(createNativePtQuoter, "createNativePtQuoter");
 function parseBigDecimalTo18(s) {
   const SCALE = 18;
   const [whole = "0", frac = ""] = s.split(".");
   const padded = (frac + "0".repeat(SCALE)).slice(0, SCALE);
   return BigInt(whole + padded);
 }
+__name(parseBigDecimalTo18, "parseBigDecimalTo18");
 
 // src/pafi-backend/client.ts
 import { getPafiServiceUrls } from "@pafi-dev/core";
@@ -4341,15 +3833,24 @@ function extractPafiErrorFields(json, status) {
   const inner = typeof json.error === "object" && json.error !== null ? json.error : null;
   const code = inner?.code ?? json.code ?? "INTERNAL_ERROR";
   const message = inner?.message ?? json.message ?? `HTTP ${status}`;
-  return { code, message };
+  return {
+    code,
+    message
+  };
 }
+__name(extractPafiErrorFields, "extractPafiErrorFields");
 function serializeBigInt(_key, value) {
   return typeof value === "bigint" ? value.toString(10) : value;
 }
+__name(serializeBigInt, "serializeBigInt");
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+__name(sleep, "sleep");
 var PafiBackendClient = class {
+  static {
+    __name(this, "PafiBackendClient");
+  }
   config;
   baseUrl;
   constructor(config) {
@@ -4387,11 +3888,11 @@ var PafiBackendClient = class {
     throw lastError;
   }
   /**
-   * Fetch ERC-4337 UserOp receipt via PAFI's authenticated bundler proxy.
-   * Returns `null` when the bundler hasn't seen the userOp yet — caller
-   * should keep polling. Used by status endpoints to short-circuit the
-   * on-chain indexer when several PENDING locks share the same amount.
-   */
+  * Fetch ERC-4337 UserOp receipt via PAFI's authenticated bundler proxy.
+  * Returns `null` when the bundler hasn't seen the userOp yet — caller
+  * should keep polling. Used by status endpoints to short-circuit the
+  * on-chain indexer when several PENDING locks share the same amount.
+  */
   async getUserOpReceipt(userOpHash) {
     const fetchFn = this.config.fetchImpl ?? fetch;
     const url = `${this.baseUrl}/bundler/receipt`;
@@ -4404,14 +3905,12 @@ var PafiBackendClient = class {
           Authorization: `Bearer ${this.config.apiKey}`,
           "X-Issuer-Id": this.config.issuerId
         },
-        body: JSON.stringify({ userOpHash })
+        body: JSON.stringify({
+          userOpHash
+        })
       });
     } catch (err) {
-      throw new PafiBackendError(
-        "NETWORK_ERROR",
-        `Network error: ${err instanceof Error ? err.message : String(err)}`,
-        0
-      );
+      throw new PafiBackendError("NETWORK_ERROR", `Network error: ${err instanceof Error ? err.message : String(err)}`, 0);
     }
     const text = await response.text();
     let json = {};
@@ -4445,11 +3944,7 @@ var PafiBackendClient = class {
         body: JSON.stringify(request)
       });
     } catch (err) {
-      throw new PafiBackendError(
-        "NETWORK_ERROR",
-        `Network error: ${err instanceof Error ? err.message : String(err)}`,
-        0
-      );
+      throw new PafiBackendError("NETWORK_ERROR", `Network error: ${err instanceof Error ? err.message : String(err)}`, 0);
     }
     const text = await response.text();
     let json = {};
@@ -4461,7 +3956,9 @@ var PafiBackendClient = class {
       const { code, message } = extractPafiErrorFields(json, response.status);
       throw new PafiBackendError(code, message, response.status, json);
     }
-    return { userOpHash: json.userOpHash };
+    return {
+      userOpHash: json.userOpHash
+    };
   }
   async _doRequest(request) {
     const fetchFn = this.config.fetchImpl ?? fetch;
@@ -4479,11 +3976,7 @@ var PafiBackendClient = class {
         body
       });
     } catch (err) {
-      throw new PafiBackendError(
-        "NETWORK_ERROR",
-        `Network error: ${err instanceof Error ? err.message : String(err)}`,
-        0
-      );
+      throw new PafiBackendError("NETWORK_ERROR", `Network error: ${err instanceof Error ? err.message : String(err)}`, 0);
     }
     const text = await response.text();
     let json = {};
@@ -4504,9 +3997,7 @@ var PafiBackendClient = class {
     return {
       paymaster: json.paymaster,
       paymasterData: json.paymasterData,
-      paymasterVerificationGasLimit: BigInt(
-        json.paymasterVerificationGasLimit
-      ),
+      paymasterVerificationGasLimit: BigInt(json.paymasterVerificationGasLimit),
       paymasterPostOpGasLimit: BigInt(json.paymasterPostOpGasLimit),
       callGasLimit: json.callGasLimit != null ? BigInt(json.callGasLimit) : void 0,
       verificationGasLimit: json.verificationGasLimit != null ? BigInt(json.verificationGasLimit) : void 0,
@@ -4519,8 +4010,8 @@ var PafiBackendClient = class {
 };
 
 // src/config.ts
-import { getAddress as getAddress12 } from "viem";
-import { getContractAddresses as getContractAddresses7 } from "@pafi-dev/core";
+import { getAddress as getAddress11 } from "viem";
+import { getContractAddresses as getContractAddresses5 } from "@pafi-dev/core";
 
 // src/redemption/evaluator.ts
 var SECONDS_PER_DAY = 24 * 60 * 60;
@@ -4530,10 +4021,7 @@ function evaluateRedemption(input) {
   const cooldownUntilUnixSec = history.lastRedeemedAtUnixSec !== null ? history.lastRedeemedAtUnixSec + policy.cooldownSec : null;
   const inCooldown = cooldownUntilUnixSec !== null && cooldownUntilUnixSec > nowUnixSec;
   const activeBlackout = findActiveBlackout(policy.blackoutWindows, nowUnixSec);
-  const nextBlackoutEnd = nextBlackoutEndAfter(
-    policy.blackoutWindows,
-    nowUnixSec
-  );
+  const nextBlackoutEnd = nextBlackoutEndAfter(policy.blackoutWindows, nowUnixSec);
   let availableAmountPt = 0n;
   if (!inCooldown && !activeBlackout) {
     const headroom = dailyRemaining < policy.perTxMaxPt ? dailyRemaining : policy.perTxMaxPt;
@@ -4550,7 +4038,11 @@ function evaluateRedemption(input) {
     policySource
   };
   if (amountPt <= 0n) {
-    return { allowed: false, preview, denial: rejectAmountBelowMin(policy) };
+    return {
+      allowed: false,
+      preview,
+      denial: rejectAmountBelowMin(policy)
+    };
   }
   const denial = firstDenial({
     amountPt,
@@ -4560,25 +4052,29 @@ function evaluateRedemption(input) {
     cooldownUntilUnixSec,
     activeBlackout
   });
-  if (denial) return { allowed: false, denial, preview };
-  return { allowed: true, preview };
+  if (denial) return {
+    allowed: false,
+    denial,
+    preview
+  };
+  return {
+    allowed: true,
+    preview
+  };
 }
+__name(evaluateRedemption, "evaluateRedemption");
 function firstDenial(args) {
   const { amountPt, policy, dailyRemaining, inCooldown, cooldownUntilUnixSec, activeBlackout } = args;
   if (activeBlackout) {
     return {
       code: "BLACKOUT_WINDOW",
-      message: `Redemption is blocked until ${new Date(
-        activeBlackout.endUnixSec * 1e3
-      ).toISOString()}${activeBlackout.reason ? ` (${activeBlackout.reason})` : ""}`
+      message: `Redemption is blocked until ${new Date(activeBlackout.endUnixSec * 1e3).toISOString()}${activeBlackout.reason ? ` (${activeBlackout.reason})` : ""}`
     };
   }
   if (inCooldown && cooldownUntilUnixSec !== null) {
     return {
       code: "COOLDOWN_ACTIVE",
-      message: `Cooldown active until ${new Date(
-        cooldownUntilUnixSec * 1e3
-      ).toISOString()}`
+      message: `Cooldown active until ${new Date(cooldownUntilUnixSec * 1e3).toISOString()}`
     };
   }
   if (amountPt < policy.perTxMinPt) {
@@ -4601,18 +4097,21 @@ function firstDenial(args) {
   }
   return null;
 }
+__name(firstDenial, "firstDenial");
 function rejectAmountBelowMin(policy) {
   return {
     code: "AMOUNT_BELOW_MIN",
     message: `amount must be >= ${policy.perTxMinPt}`
   };
 }
+__name(rejectAmountBelowMin, "rejectAmountBelowMin");
 function findActiveBlackout(windows, nowUnixSec) {
   for (const w of windows) {
     if (w.startUnixSec <= nowUnixSec && nowUnixSec < w.endUnixSec) return w;
   }
   return null;
 }
+__name(findActiveBlackout, "findActiveBlackout");
 function nextBlackoutEndAfter(windows, nowUnixSec) {
   let earliest = null;
   for (const w of windows) {
@@ -4622,17 +4121,19 @@ function nextBlackoutEndAfter(windows, nowUnixSec) {
   }
   return earliest;
 }
+__name(nextBlackoutEndAfter, "nextBlackoutEndAfter");
 var REDEMPTION_HISTORY_WINDOW_SEC = SECONDS_PER_DAY;
 
 // src/redemption/policyProvider.ts
 import { PafiSdkError as PafiSdkError2 } from "@pafi-dev/core";
 
 // src/redemption/settlementClient.ts
-import {
-  getPafiServiceUrls as getPafiServiceUrls2
-} from "@pafi-dev/core";
+import { getPafiServiceUrls as getPafiServiceUrls2 } from "@pafi-dev/core";
 var DEFAULT_TIMEOUT_MS = 1e3;
 var SettlementClient = class {
+  static {
+    __name(this, "SettlementClient");
+  }
   config;
   constructor(config) {
     if (!config.chainId) throw new Error("SettlementClient: chainId is required");
@@ -4652,10 +4153,7 @@ var SettlementClient = class {
     const fetchFn = this.config.fetchImpl ?? fetch;
     const url = `${this.config.baseUrl}/issuers/${encodeURIComponent(this.config.issuerId)}/redemption-policy`;
     const controller = new AbortController();
-    const timer = setTimeout(
-      () => controller.abort(),
-      this.config.fetchTimeoutMs
-    );
+    const timer = setTimeout(() => controller.abort(), this.config.fetchTimeoutMs);
     let response;
     try {
       response = await fetchFn(url, {
@@ -4669,30 +4167,56 @@ var SettlementClient = class {
       });
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || /aborted|timeout/i.test(err.message ?? ""));
-      return { ok: false, reason: isAbort ? "TIMEOUT" : "NETWORK" };
+      return {
+        ok: false,
+        reason: isAbort ? "TIMEOUT" : "NETWORK"
+      };
     } finally {
       clearTimeout(timer);
     }
     if (response.status === 404) {
-      return { ok: false, reason: "NOT_FOUND", status: 404 };
+      return {
+        ok: false,
+        reason: "NOT_FOUND",
+        status: 404
+      };
     }
     if (response.status === 401 || response.status === 403) {
-      return { ok: false, reason: "UNAUTHORIZED", status: response.status };
+      return {
+        ok: false,
+        reason: "UNAUTHORIZED",
+        status: response.status
+      };
     }
     if (!response.ok) {
-      return { ok: false, reason: "SERVER_ERROR", status: response.status };
+      return {
+        ok: false,
+        reason: "SERVER_ERROR",
+        status: response.status
+      };
     }
     let raw;
     try {
       raw = await response.json();
     } catch {
-      return { ok: false, reason: "INVALID_RESPONSE", status: response.status };
+      return {
+        ok: false,
+        reason: "INVALID_RESPONSE",
+        status: response.status
+      };
     }
     const parsed = parsePolicyDto(raw);
     if (!parsed) {
-      return { ok: false, reason: "INVALID_RESPONSE", status: response.status };
+      return {
+        ok: false,
+        reason: "INVALID_RESPONSE",
+        status: response.status
+      };
     }
-    return { ok: true, policy: parsed };
+    return {
+      ok: true,
+      policy: parsed
+    };
   }
 };
 function parsePolicyDto(raw) {
@@ -4715,6 +4239,7 @@ function parsePolicyDto(raw) {
     return null;
   }
 }
+__name(parsePolicyDto, "parsePolicyDto");
 function normalizeBlackout(raw) {
   if (!raw || typeof raw !== "object") return null;
   const win = raw;
@@ -4727,6 +4252,7 @@ function normalizeBlackout(raw) {
     reason: typeof win.reason === "string" ? win.reason : void 0
   };
 }
+__name(normalizeBlackout, "normalizeBlackout");
 
 // src/redemption/defaults.ts
 var PT_DECIMALS = 10n ** 18n;
@@ -4740,23 +4266,34 @@ var DEFAULT_REDEMPTION_POLICY = {
   version: "default-v1"
 };
 function defaultPolicyFor(issuerId) {
-  return { ...DEFAULT_REDEMPTION_POLICY, issuerId };
+  return {
+    ...DEFAULT_REDEMPTION_POLICY,
+    issuerId
+  };
 }
+__name(defaultPolicyFor, "defaultPolicyFor");
 
 // src/redemption/policyProvider.ts
 var DEFAULT_CACHE_TTL_MS3 = 5 * 60 * 1e3;
 var PolicyProviderUnavailableError = class extends PafiSdkError2 {
+  static {
+    __name(this, "PolicyProviderUnavailableError");
+  }
   code = "POLICY_PROVIDER_UNAVAILABLE";
   httpStatus = "service_unavailable";
   details;
   constructor(issuerId, reason) {
-    super(
-      `Redemption policy provider unavailable for issuer ${issuerId}: ${reason}. Pre-flight redeem limit cannot be enforced \u2014 refusing to sign BurnRequest. Mobile FE: surface "try again shortly" and retry with backoff.`
-    );
-    this.details = { issuerId, reason };
+    super(`Redemption policy provider unavailable for issuer ${issuerId}: ${reason}. Pre-flight redeem limit cannot be enforced \u2014 refusing to sign BurnRequest. Mobile FE: surface "try again shortly" and retry with backoff.`);
+    this.details = {
+      issuerId,
+      reason
+    };
   }
 };
 var PolicyProvider = class {
+  static {
+    __name(this, "PolicyProvider");
+  }
   client;
   issuerId;
   cacheTtlMs;
@@ -4775,7 +4312,10 @@ var PolicyProvider = class {
   }
   async getPolicy() {
     const fresh = this.readCache();
-    if (fresh) return { policy: fresh, source: "cache" };
+    if (fresh) return {
+      policy: fresh,
+      source: "cache"
+    };
     if (this.inflight) return this.inflight;
     this.inflight = this.fetchAndStore().finally(() => {
       this.inflight = null;
@@ -4801,19 +4341,22 @@ var PolicyProvider = class {
         policy: result.policy,
         expiresAtMs: this.now() + this.cacheTtlMs
       };
-      return { policy: result.policy, source: "settlement" };
+      return {
+        policy: result.policy,
+        source: "settlement"
+      };
     }
     const reason = "reason" in result && typeof result.reason === "string" ? result.reason : "unknown";
     if (this.onFetchFailure === "permissive-default") {
-      this.onWarning?.(
-        "PolicyProvider: settlement-api unreachable, falling back to permissive default. Pre-flight redeem limit is DEGRADED until settlement-api recovers.",
-        {
-          event: "policy_provider_fallback",
-          issuerId: this.issuerId,
-          reason
-        }
-      );
-      return { policy: defaultPolicyFor(this.issuerId), source: "default" };
+      this.onWarning?.("PolicyProvider: settlement-api unreachable, falling back to permissive default. Pre-flight redeem limit is DEGRADED until settlement-api recovers.", {
+        event: "policy_provider_fallback",
+        issuerId: this.issuerId,
+        reason
+      });
+      return {
+        policy: defaultPolicyFor(this.issuerId),
+        source: "default"
+      };
     }
     throw new PolicyProviderUnavailableError(this.issuerId, reason);
   }
@@ -4821,6 +4364,9 @@ var PolicyProvider = class {
 
 // src/redemption/service.ts
 var RedemptionService = class {
+  static {
+    __name(this, "RedemptionService");
+  }
   policyProvider;
   historyStore;
   nowUnixSec;
@@ -4837,17 +4383,16 @@ var RedemptionService = class {
     const { policy, source } = await this.policyProvider.getPolicy();
     const now = this.nowUnixSec();
     const [redeemedLast24hPt, lastRedeemedAtUnixSec] = await Promise.all([
-      this.historyStore.sumRedeemedSince(
-        user,
-        now - REDEMPTION_HISTORY_WINDOW_SEC,
-        pointTokenAddress
-      ),
+      this.historyStore.sumRedeemedSince(user, now - REDEMPTION_HISTORY_WINDOW_SEC, pointTokenAddress),
       this.historyStore.getLastRedeemedAtUnixSec(user, pointTokenAddress)
     ]);
     return evaluateRedemption({
       policy,
       policySource: source,
-      history: { redeemedLast24hPt, lastRedeemedAtUnixSec },
+      history: {
+        redeemedLast24hPt,
+        lastRedeemedAtUnixSec
+      },
       amountPt,
       nowUnixSec: now
     });
@@ -4874,16 +4419,18 @@ async function createIssuerService(config) {
   if (!config.auth?.domain) {
     throw new Error("createIssuerService: auth.domain is required");
   }
-  const rawAddresses = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [config.pointTokenAddress] : [];
+  const rawAddresses = config.pointTokenAddresses && config.pointTokenAddresses.length > 0 ? config.pointTokenAddresses : config.pointTokenAddress ? [
+    config.pointTokenAddress
+  ] : [];
   if (rawAddresses.length === 0) {
-    throw new Error(
-      "createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required"
-    );
+    throw new Error("createIssuerService: at least one of pointTokenAddress / pointTokenAddresses is required");
   }
-  const tokenAddresses = rawAddresses.map((a) => getAddress12(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 });
+  const policy = config.policy ?? new DefaultPolicyEngine({
+    ledger
+  });
   const authServiceConfig = {
     sessionStore,
     jwtSecret: config.auth.jwtSecret,
@@ -4905,15 +4452,13 @@ async function createIssuerService(config) {
       provider: config.provider
     });
   }
-  const sdkWrapperAddress = getContractAddresses7(config.chainId).mintFeeWrapper;
+  const sdkWrapperAddress = getContractAddresses5(config.chainId).mintFeeWrapper;
   const wrapperOverride = config.indexer?.mintFeeWrapperAddress;
   const resolvedWrapperAddress = wrapperOverride !== void 0 ? wrapperOverride : sdkWrapperAddress;
   const baseCursorStore = config.indexer?.cursorStore;
   const sharedCursorWithMultipleTokens = baseCursorStore !== void 0 && typeof baseCursorStore.forKey !== "function" && tokenAddresses.length > 1;
   if (sharedCursorWithMultipleTokens) {
-    console.warn(
-      `[@pafi-dev/issuer] cursorStore lacks forKey() and ${tokenAddresses.length} PointTokens are configured. All PointIndexers will share one cursor row, causing token-skipping. Implement IIndexerCursorStore.forKey to return per-token derived stores. This permissive path will be removed in a future major release.`
-    );
+    console.warn(`[@pafi-dev/issuer] cursorStore lacks forKey() and ${tokenAddresses.length} PointTokens are configured. All PointIndexers will share one cursor row, causing token-skipping. Implement IIndexerCursorStore.forKey to return per-token derived stores. This permissive path will be removed in a future major release.`);
   }
   const indexers = /* @__PURE__ */ new Map();
   for (const tokenAddress of tokenAddresses) {
@@ -4929,9 +4474,7 @@ async function createIssuerService(config) {
       indexerConfig.fromBlock = config.indexer.fromBlock;
     }
     if (baseCursorStore) {
-      indexerConfig.cursorStore = typeof baseCursorStore.forKey === "function" ? baseCursorStore.forKey(
-        `point-indexer:${tokenAddress.toLowerCase()}`
-      ) : baseCursorStore;
+      indexerConfig.cursorStore = typeof baseCursorStore.forKey === "function" ? baseCursorStore.forKey(`point-indexer:${tokenAddress.toLowerCase()}`) : baseCursorStore;
     }
     if (config.indexer?.confirmations !== void 0) {
       indexerConfig.confirmations = config.indexer.confirmations;
@@ -4944,9 +4487,9 @@ async function createIssuerService(config) {
     }
     indexers.set(tokenAddress, new PointIndexer(indexerConfig));
   }
-  const chainAddresses = getContractAddresses7(config.chainId);
+  const chainAddresses = getContractAddresses5(config.chainId);
   const resolvedContracts = {
-    batchExecutor: chainAddresses.batchExecutor,
+    kernel: chainAddresses.kernel,
     usdt: chainAddresses.usdt,
     issuerRegistry: chainAddresses.issuerRegistry,
     mintingOracle: chainAddresses.mintingOracle,
@@ -5002,9 +4545,7 @@ async function createIssuerService(config) {
   if (config.indexer?.autoStart) {
     const lock = config.indexer.singletonLock;
     if (!lock) {
-      console.warn(
-        "[@pafi-dev/issuer] indexer.autoStart=true without singletonLock \u2014 this is UNSAFE in multi-replica deployments. Either set replicas=1 + INDEXER_AUTOSTART=false on non-leader pods, or pass `singletonLock: makePostgresSingletonLock(dataSource)`. This permissive path will be removed in a future major release."
-      );
+      console.warn("[@pafi-dev/issuer] indexer.autoStart=true without singletonLock \u2014 this is UNSAFE in multi-replica deployments. Either set replicas=1 + INDEXER_AUTOSTART=false on non-leader pods, or pass `singletonLock: makePostgresSingletonLock(dataSource)`. This permissive path will be removed in a future major release.");
       for (const idx of indexers.values()) {
         idx.start();
       }
@@ -5033,42 +4574,42 @@ async function createIssuerService(config) {
     redemption
   };
 }
+__name(createIssuerService, "createIssuerService");
 
 // src/issuer-state/validator.ts
-import { getAddress as getAddress13 } from "viem";
-import {
-  POINT_TOKEN_ABI as POINT_TOKEN_ABI3,
-  issuerRegistryAbi,
-  getContractAddresses as getContractAddresses8
-} from "@pafi-dev/core";
+import { getAddress as getAddress12 } from "viem";
+import { POINT_TOKEN_ABI as POINT_TOKEN_ABI3, issuerRegistryAbi, getContractAddresses as getContractAddresses6 } from "@pafi-dev/core";
 var ISSUER_RECORD_TTL_MS = 1e4;
 var IssuerStateValidator = class _IssuerStateValidator {
-  constructor(provider, registryAddress) {
-    this.provider = provider;
-    this.registryAddress = registryAddress;
+  static {
+    __name(this, "IssuerStateValidator");
   }
   provider;
   registryAddress;
   pointTokenIssuerCache = /* @__PURE__ */ new Map();
   stateCache = /* @__PURE__ */ new Map();
   inflight = /* @__PURE__ */ new Map();
+  constructor(provider, registryAddress) {
+    this.provider = provider;
+    this.registryAddress = registryAddress;
+  }
   /**
-   * Convenience factory — reads `registryAddress` from the SDK
-   * `CONTRACT_ADDRESSES` map for the given chain.
-   */
+  * Convenience factory — reads `registryAddress` from the SDK
+  * `CONTRACT_ADDRESSES` map for the given chain.
+  */
   static forChain(provider, chainId) {
-    const { issuerRegistry } = getContractAddresses8(chainId);
+    const { issuerRegistry } = getContractAddresses6(chainId);
     return new _IssuerStateValidator(provider, issuerRegistry);
   }
   /**
-   * Invalidate cached state for one PointToken, or everything if omitted.
-   * Call after admin txs that change registry or cap settings — closes
-   * the split-brain window described 
-   * passive TTL. Idempotent: safe to call when no entry exists.
-   */
+  * Invalidate cached state for one PointToken, or everything if omitted.
+  * Call after admin txs that change registry or cap settings — closes
+  * the split-brain window described 
+  * passive TTL. Idempotent: safe to call when no entry exists.
+  */
   invalidate(pointToken) {
     if (pointToken) {
-      const key = getAddress13(pointToken);
+      const key = getAddress12(pointToken);
       this.pointTokenIssuerCache.delete(key);
       this.stateCache.delete(key);
       this.inflight.delete(key);
@@ -5079,11 +4620,11 @@ var IssuerStateValidator = class _IssuerStateValidator {
     }
   }
   /**
-   * Resolve `PointToken.issuer()` once per token and memoize.
-   * The issuer field is set at `initialize()` and never changes.
-   */
+  * Resolve `PointToken.issuer()` once per token and memoize.
+  * The issuer field is set at `initialize()` and never changes.
+  */
   async getIssuerAddressForPointToken(pointToken) {
-    const key = getAddress13(pointToken);
+    const key = getAddress12(pointToken);
     const cached = this.pointTokenIssuerCache.get(key);
     if (cached) return cached;
     const issuer = await this.provider.readContract({
@@ -5091,15 +4632,15 @@ var IssuerStateValidator = class _IssuerStateValidator {
       abi: POINT_TOKEN_ABI3,
       functionName: "issuer"
     });
-    this.pointTokenIssuerCache.set(key, getAddress13(issuer));
-    return getAddress13(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.
-   */
+  * 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 = getAddress13(pointToken);
+    const tokenAddr = getAddress12(pointToken);
     const now = Date.now();
     const cached = this.stateCache.get(tokenAddr);
     if (cached && cached.expiresAt > now) return cached.value;
@@ -5118,49 +4659,41 @@ var IssuerStateValidator = class _IssuerStateValidator {
     return promise;
   }
   /**
-   * Validate that `amount` PT can be minted on `pointToken` right now.
-   *
-   * Throws `IssuerStateError` with:
-   *   - `ISSUER_NOT_REGISTERED` — registry has no record for this issuer
-   *   - `ISSUER_INACTIVE`       — issuer.active is false
-   *   - `MINT_CAP_EXCEEDED`     — totalSupply + amount would exceed hardCap
-   *
-   * Returns the fetched state on success so callers can log without a
-   * second RPC round-trip.
-   */
+  * Validate that `amount` PT can be minted on `pointToken` right now.
+  *
+  * Throws `IssuerStateError` with:
+  *   - `ISSUER_NOT_REGISTERED` — registry has no record for this issuer
+  *   - `ISSUER_INACTIVE`       — issuer.active is false
+  *   - `MINT_CAP_EXCEEDED`     — totalSupply + amount would exceed hardCap
+  *
+  * Returns the fetched state on success so callers can log without a
+  * second RPC round-trip.
+  */
   async preValidateMint(pointToken, amount) {
     let state;
     try {
       state = await this.getIssuerState(pointToken);
     } catch (err) {
       if (err.message.includes("IssuerNotFound")) {
-        throw new IssuerStateError(
-          "ISSUER_NOT_REGISTERED",
-          `IssuerRegistry has no record for PointToken ${pointToken}`,
-          { pointToken }
-        );
+        throw new IssuerStateError("ISSUER_NOT_REGISTERED", `IssuerRegistry has no record for PointToken ${pointToken}`, {
+          pointToken
+        });
       }
       throw err;
     }
     const { issuer, equityCap, equitySupply, remaining } = state;
     if (!issuer.active) {
-      throw new IssuerStateError(
-        "ISSUER_INACTIVE",
-        `Issuer "${issuer.name}" is deactivated on IssuerRegistry`,
-        { pointToken }
-      );
+      throw new IssuerStateError("ISSUER_INACTIVE", `Issuer "${issuer.name}" is deactivated on IssuerRegistry`, {
+        pointToken
+      });
     }
     if (equitySupply + amount > equityCap.hardCap) {
-      throw new IssuerStateError(
-        "MINT_CAP_EXCEEDED",
-        `Requested ${amount} PT would exceed EQUITY mint cap. Cap=${equityCap.hardCap}, equityMinted=${equitySupply}, remaining=${remaining}`,
-        {
-          requested: amount.toString(),
-          cap: equityCap.hardCap.toString(),
-          equityMinted: equitySupply.toString(),
-          remaining: remaining.toString()
-        }
-      );
+      throw new IssuerStateError("MINT_CAP_EXCEEDED", `Requested ${amount} PT would exceed EQUITY mint cap. Cap=${equityCap.hardCap}, equityMinted=${equitySupply}, remaining=${remaining}`, {
+        requested: amount.toString(),
+        cap: equityCap.hardCap.toString(),
+        equityMinted: equitySupply.toString(),
+        remaining: remaining.toString()
+      });
     }
     return state;
   }
@@ -5170,7 +4703,9 @@ var IssuerStateValidator = class _IssuerStateValidator {
       address: this.registryAddress,
       abi: issuerRegistryAbi,
       functionName: "getIssuer",
-      args: [issuerAddr]
+      args: [
+        issuerAddr
+      ]
     });
     const issuer = {
       signerAddress: issuerStruct.signerAddress,
@@ -5202,6 +4737,9 @@ var IssuerStateValidator = class _IssuerStateValidator {
 
 // src/redemption/memoryHistoryStore.ts
 var MemoryRedemptionHistoryStore = class {
+  static {
+    __name(this, "MemoryRedemptionHistoryStore");
+  }
   entries = [];
   async sumRedeemedSince(user, sinceUnixSec, pointTokenAddress) {
     const userKey = user.toLowerCase();
@@ -5237,7 +4775,7 @@ var MemoryRedemptionHistoryStore = class {
 };
 
 // src/index.ts
-var PAFI_ISSUER_SDK_VERSION = true ? "0.39.2" : "dev";
+var PAFI_ISSUER_SDK_VERSION = true ? "0.40.0" : "dev";
 export {
   AdapterMisconfiguredError,
   AuthError,
@@ -5301,7 +4839,6 @@ export {
   defaultPolicyFor,
   evaluateRedemption,
   handleClaimStatus,
-  handleDelegateSubmit,
   handleMobilePrepare,
   handleMobileSubmit,
   handleRedeemStatus,
@@ -5313,7 +4850,6 @@ export {
   prepareMobileUserOp,
   relayUserOp,
   requestPaymaster,
-  serializeEntryToJsonRpc,
-  serializeUserOpTypedData
+  serializeEntryToJsonRpc
 };
 //# sourceMappingURL=index.js.map