@zendfi/sdk 0.8.4 → 1.0.1

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,417 +27,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/helpers/cache.ts
-var cache_exports = {};
-__export(cache_exports, {
-  QuickCaches: () => QuickCaches,
-  SessionKeyCache: () => SessionKeyCache
-});
-var SessionKeyCache, QuickCaches;
-var init_cache = __esm({
-  "src/helpers/cache.ts"() {
-    "use strict";
-    SessionKeyCache = class {
-      memoryCache = /* @__PURE__ */ new Map();
-      config;
-      refreshTimers = /* @__PURE__ */ new Map();
-      constructor(config = {}) {
-        this.config = {
-          storage: config.storage || "memory",
-          ttl: config.ttl || 30 * 60 * 1e3,
-          // 30 minutes default
-          autoRefresh: config.autoRefresh || false,
-          namespace: config.namespace || "zendfi_cache",
-          debug: config.debug || false
-        };
-      }
-      /**
-       * Get cached keypair or decrypt and cache
-       */
-      async getCached(sessionKeyId, decryptFn, options) {
-        this.log(`getCached: ${sessionKeyId}`);
-        const memoryCached = this.memoryCache.get(sessionKeyId);
-        if (memoryCached && Date.now() < memoryCached.expiry) {
-          this.log(`Memory cache HIT: ${sessionKeyId}`);
-          return memoryCached.keypair;
-        }
-        if (this.config.storage !== "memory") {
-          const persistentCached = await this.getFromStorage(sessionKeyId);
-          if (persistentCached && Date.now() < persistentCached.expiry) {
-            if (options?.deviceFingerprint && persistentCached.deviceFingerprint) {
-              if (options.deviceFingerprint !== persistentCached.deviceFingerprint) {
-                this.log(`Device fingerprint mismatch for ${sessionKeyId}`);
-                await this.invalidate(sessionKeyId);
-                return await this.decryptAndCache(sessionKeyId, decryptFn, options);
-              }
-            }
-            this.log(`Persistent cache HIT: ${sessionKeyId}`);
-            this.memoryCache.set(sessionKeyId, persistentCached);
-            return persistentCached.keypair;
-          }
-        }
-        this.log(`Cache MISS: ${sessionKeyId}`);
-        return await this.decryptAndCache(sessionKeyId, decryptFn, options);
-      }
-      /**
-       * Decrypt keypair and cache it
-       */
-      async decryptAndCache(sessionKeyId, decryptFn, options) {
-        const keypair = await decryptFn();
-        const expiry = Date.now() + this.config.ttl;
-        const cached = {
-          keypair,
-          expiry,
-          sessionKeyId,
-          deviceFingerprint: options?.deviceFingerprint
-        };
-        this.memoryCache.set(sessionKeyId, cached);
-        if (this.config.storage !== "memory") {
-          await this.setInStorage(sessionKeyId, cached);
-        }
-        if (this.config.autoRefresh) {
-          this.setupAutoRefresh(sessionKeyId, decryptFn, options);
-        }
-        this.log(`Cached: ${sessionKeyId}, expires in ${this.config.ttl}ms`);
-        return keypair;
-      }
-      /**
-       * Invalidate cached keypair
-       */
-      async invalidate(sessionKeyId) {
-        this.log(`Invalidating: ${sessionKeyId}`);
-        this.memoryCache.delete(sessionKeyId);
-        const timer = this.refreshTimers.get(sessionKeyId);
-        if (timer) {
-          clearTimeout(timer);
-          this.refreshTimers.delete(sessionKeyId);
-        }
-        if (this.config.storage !== "memory") {
-          await this.removeFromStorage(sessionKeyId);
-        }
-      }
-      /**
-       * Clear all cached keypairs
-       */
-      async clear() {
-        this.log("Clearing all cache");
-        this.memoryCache.clear();
-        for (const timer of this.refreshTimers.values()) {
-          clearTimeout(timer);
-        }
-        this.refreshTimers.clear();
-        if (this.config.storage !== "memory") {
-          await this.clearStorage();
-        }
-      }
-      /**
-       * Get cache statistics
-       */
-      getStats() {
-        const entries = Array.from(this.memoryCache.entries()).map(([id, cached]) => ({
-          sessionKeyId: id,
-          expiresIn: Math.max(0, cached.expiry - Date.now())
-        }));
-        return { size: this.memoryCache.size, entries };
-      }
-      /**
-       * Check if a session key is cached and valid
-       */
-      isCached(sessionKeyId) {
-        const cached = this.memoryCache.get(sessionKeyId);
-        return cached ? Date.now() < cached.expiry : false;
-      }
-      /**
-       * Update TTL for a cached session key
-       */
-      async extendTTL(sessionKeyId, additionalMs) {
-        const cached = this.memoryCache.get(sessionKeyId);
-        if (!cached) return false;
-        cached.expiry += additionalMs;
-        this.memoryCache.set(sessionKeyId, cached);
-        if (this.config.storage !== "memory") {
-          await this.setInStorage(sessionKeyId, cached);
-        }
-        this.log(`Extended TTL for ${sessionKeyId} by ${additionalMs}ms`);
-        return true;
-      }
-      // ============================================
-      // Storage Backend Implementations
-      // ============================================
-      async getFromStorage(sessionKeyId) {
-        try {
-          const key = this.getStorageKey(sessionKeyId);
-          if (this.config.storage === "localStorage") {
-            const data = localStorage.getItem(key);
-            if (!data) return null;
-            const parsed = JSON.parse(data);
-            return {
-              ...parsed,
-              keypair: this.deserializeKeypair(parsed.keypair)
-            };
-          }
-          if (this.config.storage === "indexedDB") {
-            return await this.getFromIndexedDB(key);
-          }
-          if (typeof this.config.storage === "object") {
-            const data = await this.config.storage.get(key);
-            if (!data) return null;
-            const parsed = JSON.parse(data);
-            return {
-              ...parsed,
-              keypair: this.deserializeKeypair(parsed.keypair)
-            };
-          }
-        } catch (error) {
-          this.log(`Error reading from storage: ${error}`);
-        }
-        return null;
-      }
-      async setInStorage(sessionKeyId, cached) {
-        try {
-          const key = this.getStorageKey(sessionKeyId);
-          const serialized = {
-            ...cached,
-            keypair: this.serializeKeypair(cached.keypair)
-          };
-          if (this.config.storage === "localStorage") {
-            localStorage.setItem(key, JSON.stringify(serialized));
-            return;
-          }
-          if (this.config.storage === "indexedDB") {
-            await this.setInIndexedDB(key, serialized);
-            return;
-          }
-          if (typeof this.config.storage === "object") {
-            await this.config.storage.set(key, JSON.stringify(serialized));
-          }
-        } catch (error) {
-          this.log(`Error writing to storage: ${error}`);
-        }
-      }
-      async removeFromStorage(sessionKeyId) {
-        try {
-          const key = this.getStorageKey(sessionKeyId);
-          if (this.config.storage === "localStorage") {
-            localStorage.removeItem(key);
-            return;
-          }
-          if (this.config.storage === "indexedDB") {
-            await this.removeFromIndexedDB(key);
-            return;
-          }
-          if (typeof this.config.storage === "object") {
-            await this.config.storage.remove(key);
-          }
-        } catch (error) {
-          this.log(`Error removing from storage: ${error}`);
-        }
-      }
-      async clearStorage() {
-        try {
-          if (this.config.storage === "localStorage") {
-            const keysToRemove = [];
-            for (let i = 0; i < localStorage.length; i++) {
-              const key = localStorage.key(i);
-              if (key?.startsWith(this.config.namespace)) {
-                keysToRemove.push(key);
-              }
-            }
-            keysToRemove.forEach((key) => localStorage.removeItem(key));
-            return;
-          }
-          if (this.config.storage === "indexedDB") {
-            await this.clearIndexedDB();
-            return;
-          }
-          if (typeof this.config.storage === "object") {
-            await this.config.storage.clear();
-          }
-        } catch (error) {
-          this.log(`Error clearing storage: ${error}`);
-        }
-      }
-      // ============================================
-      // IndexedDB Helpers
-      // ============================================
-      async getFromIndexedDB(key) {
-        return new Promise((resolve) => {
-          const request = indexedDB.open(this.config.namespace, 1);
-          request.onerror = () => resolve(null);
-          request.onupgradeneeded = (event) => {
-            const db = event.target.result;
-            if (!db.objectStoreNames.contains("cache")) {
-              db.createObjectStore("cache");
-            }
-          };
-          request.onsuccess = (event) => {
-            const db = event.target.result;
-            const transaction = db.transaction(["cache"], "readonly");
-            const store = transaction.objectStore("cache");
-            const getRequest = store.get(key);
-            getRequest.onsuccess = () => {
-              resolve(getRequest.result || null);
-            };
-            getRequest.onerror = () => resolve(null);
-          };
-        });
-      }
-      async setInIndexedDB(key, value) {
-        return new Promise((resolve, reject) => {
-          const request = indexedDB.open(this.config.namespace, 1);
-          request.onerror = () => reject(new Error("IndexedDB error"));
-          request.onupgradeneeded = (event) => {
-            const db = event.target.result;
-            if (!db.objectStoreNames.contains("cache")) {
-              db.createObjectStore("cache");
-            }
-          };
-          request.onsuccess = (event) => {
-            const db = event.target.result;
-            const transaction = db.transaction(["cache"], "readwrite");
-            const store = transaction.objectStore("cache");
-            store.put(value, key);
-            transaction.oncomplete = () => resolve();
-            transaction.onerror = () => reject(new Error("IndexedDB transaction error"));
-          };
-        });
-      }
-      async removeFromIndexedDB(key) {
-        return new Promise((resolve) => {
-          const request = indexedDB.open(this.config.namespace, 1);
-          request.onsuccess = (event) => {
-            const db = event.target.result;
-            const transaction = db.transaction(["cache"], "readwrite");
-            const store = transaction.objectStore("cache");
-            store.delete(key);
-            transaction.oncomplete = () => resolve();
-          };
-          request.onerror = () => resolve();
-        });
-      }
-      async clearIndexedDB() {
-        return new Promise((resolve) => {
-          const request = indexedDB.open(this.config.namespace, 1);
-          request.onsuccess = (event) => {
-            const db = event.target.result;
-            const transaction = db.transaction(["cache"], "readwrite");
-            const store = transaction.objectStore("cache");
-            store.clear();
-            transaction.oncomplete = () => resolve();
-          };
-          request.onerror = () => resolve();
-        });
-      }
-      // ============================================
-      // Serialization
-      // ============================================
-      serializeKeypair(keypair) {
-        if (keypair && typeof keypair === "object" && "secretKey" in keypair) {
-          return {
-            type: "solana",
-            secretKey: Array.from(keypair.secretKey)
-          };
-        }
-        if (keypair instanceof Uint8Array) {
-          return {
-            type: "uint8array",
-            data: Array.from(keypair)
-          };
-        }
-        return keypair;
-      }
-      deserializeKeypair(data) {
-        if (!data || typeof data !== "object") return data;
-        if (data.type === "solana" && data.secretKey) {
-          return new Uint8Array(data.secretKey);
-        }
-        if (data.type === "uint8array" && data.data) {
-          return new Uint8Array(data.data);
-        }
-        return data;
-      }
-      // ============================================
-      // Auto-Refresh
-      // ============================================
-      setupAutoRefresh(sessionKeyId, decryptFn, options) {
-        const existingTimer = this.refreshTimers.get(sessionKeyId);
-        if (existingTimer) {
-          clearTimeout(existingTimer);
-        }
-        const refreshIn = Math.max(0, this.config.ttl - 5 * 60 * 1e3);
-        const timer = setTimeout(async () => {
-          this.log(`Auto-refreshing: ${sessionKeyId}`);
-          try {
-            await this.decryptAndCache(sessionKeyId, decryptFn, options);
-          } catch (error) {
-            this.log(`Auto-refresh failed: ${error}`);
-          }
-        }, refreshIn);
-        this.refreshTimers.set(sessionKeyId, timer);
-      }
-      // ============================================
-      // Utilities
-      // ============================================
-      getStorageKey(sessionKeyId) {
-        return `${this.config.namespace}:${sessionKeyId}`;
-      }
-      log(message) {
-        if (this.config.debug) {
-          console.log(`[SessionKeyCache] ${message}`);
-        }
-      }
-    };
-    QuickCaches = {
-      /** Memory-only cache (30 minutes) */
-      memory: () => new SessionKeyCache({ storage: "memory", ttl: 30 * 60 * 1e3 }),
-      /** Persistent cache (1 hour, survives reload) */
-      persistent: () => new SessionKeyCache({ storage: "localStorage", ttl: 60 * 60 * 1e3 }),
-      /** Long-term cache (24 hours, IndexedDB) */
-      longTerm: () => new SessionKeyCache({ storage: "indexedDB", ttl: 24 * 60 * 60 * 1e3, autoRefresh: true }),
-      /** Secure cache (5 minutes, memory-only) */
-      secure: () => new SessionKeyCache({ storage: "memory", ttl: 5 * 60 * 1e3 })
-    };
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AgentAPI: () => AgentAPI,
-  AnthropicAdapter: () => AnthropicAdapter,
   ApiError: () => ApiError,
   AuthenticationError: () => AuthenticationError2,
-  AutonomyAPI: () => AutonomyAPI,
   ConfigLoader: () => ConfigLoader,
   DevTools: () => DevTools,
-  DeviceBoundSessionKey: () => DeviceBoundSessionKey,
-  DeviceFingerprintGenerator: () => DeviceFingerprintGenerator,
   ERROR_CODES: () => ERROR_CODES,
-  ErrorRecovery: () => ErrorRecovery,
-  GeminiAdapter: () => GeminiAdapter,
   InterceptorManager: () => InterceptorManager,
-  LitCryptoSigner: () => LitCryptoSigner,
   NetworkError: () => NetworkError2,
-  OpenAIAdapter: () => OpenAIAdapter,
-  PINRateLimiter: () => PINRateLimiter,
-  PINValidator: () => PINValidator,
   PaymentError: () => PaymentError,
-  PaymentIntentParser: () => PaymentIntentParser,
-  PaymentIntentsAPI: () => PaymentIntentsAPI,
   PerformanceMonitor: () => PerformanceMonitor,
-  PricingAPI: () => PricingAPI,
-  QuickCaches: () => QuickCaches,
   RateLimitError: () => RateLimitError2,
   RateLimiter: () => RateLimiter,
-  RecoveryQRGenerator: () => RecoveryQRGenerator,
-  RetryStrategy: () => RetryStrategy,
-  SPENDING_LIMIT_ACTION_CID: () => SPENDING_LIMIT_ACTION_CID,
-  SecureStorage: () => SecureStorage,
-  SessionKeyCache: () => SessionKeyCache,
-  SessionKeyCrypto: () => SessionKeyCrypto,
-  SessionKeyLifecycle: () => SessionKeyLifecycle,
-  SessionKeysAPI: () => SessionKeysAPI,
-  SmartPaymentsAPI: () => SmartPaymentsAPI,
   TransactionMonitor: () => TransactionMonitor,
   TransactionPoller: () => TransactionPoller,
   ValidationError: () => ValidationError2,
@@ -449,25 +49,17 @@ __export(index_exports, {
   ZendFiClient: () => ZendFiClient,
   ZendFiEmbeddedCheckout: () => ZendFiEmbeddedCheckout,
   ZendFiError: () => ZendFiError2,
-  asAgentKeyId: () => asAgentKeyId,
-  asEscrowId: () => asEscrowId,
   asInstallmentPlanId: () => asInstallmentPlanId,
-  asIntentId: () => asIntentId,
   asInvoiceId: () => asInvoiceId,
   asMerchantId: () => asMerchantId,
   asPaymentId: () => asPaymentId,
   asPaymentLinkCode: () => asPaymentLinkCode,
-  asSessionId: () => asSessionId,
   asSubscriptionId: () => asSubscriptionId,
   createWalletHook: () => createWalletHook,
   createZendFiError: () => createZendFiError,
-  decodeSignatureFromLit: () => decodeSignatureFromLit,
-  encodeTransactionForLit: () => encodeTransactionForLit,
   generateIdempotencyKey: () => generateIdempotencyKey,
   isZendFiError: () => isZendFiError,
   processWebhook: () => processWebhook,
-  requiresLitSigning: () => requiresLitSigning,
-  setupQuickSessionKey: () => setupQuickSessionKey,
   sleep: () => sleep,
   verifyExpressWebhook: () => verifyExpressWebhook,
   verifyNextWebhook: () => verifyNextWebhook,
@@ -482,15 +74,11 @@ var import_crypto = require("crypto");
 
 // src/types.ts
 var asPaymentId = (id) => id;
-var asSessionId = (id) => id;
-var asAgentKeyId = (id) => id;
 var asMerchantId = (id) => id;
 var asInvoiceId = (id) => id;
 var asSubscriptionId = (id) => id;
-var asEscrowId = (id) => id;
 var asInstallmentPlanId = (id) => id;
 var asPaymentLinkCode = (id) => id;
-var asIntentId = (id) => id;
 
 // src/utils.ts
 var ConfigLoader = class {
@@ -931,2257 +519,133 @@ function createInterceptors() {
   };
 }
 
-// src/aip/agent.ts
-function normalizeArrayResponse(response, key) {
-  if (Array.isArray(response)) {
-    return response;
-  }
-  return response[key] || [];
-}
-var AgentAPI = class {
-  constructor(request) {
-    this.request = request;
+// src/client.ts
+var ZendFiClient = class {
+  config;
+  interceptors;
+  constructor(options) {
+    this.config = ConfigLoader.load(options);
+    ConfigLoader.validateApiKey(this.config.apiKey);
+    this.interceptors = createInterceptors();
+    if (this.config.environment === "development" || this.config.debug) {
+      console.log(
+        `\u2713 ZendFi SDK initialized in ${this.config.mode} mode (${this.config.mode === "test" ? "devnet" : "mainnet"})`
+      );
+      if (this.config.debug) {
+        console.log("[ZendFi] Debug mode enabled");
+      }
+    }
   }
-  // ============================================
-  // Agent API Keys
-  // ============================================
   /**
-   * Create a new agent API key with scoped permissions
-   * 
-   * Agent keys (prefixed with `zai_`) have limited permissions compared to
-   * merchant keys. This enables safe delegation to AI agents.
-   * 
-   * @param request - Agent key configuration
-   * @returns The created agent key (full_key only returned on creation!)
-   * 
-   * @example
-   * ```typescript
-   * const agentKey = await zendfi.agent.createKey({
-   *   name: 'Shopping Assistant',
-   *   agent_id: 'shopping-assistant-v1',
-   *   scopes: ['create_payments'],
-   *   rate_limit_per_hour: 500,
-   * });
-   * 
-   * // IMPORTANT: Save the full_key now - it won't be shown again!
-   * console.log(agentKey.full_key); // => "zai_test_abc123..."
-   * ```
+   * Create a new payment
    */
-  async createKey(request) {
-    return this.request("POST", "/api/v1/agent-keys", {
-      name: request.name,
-      agent_id: request.agent_id,
-      agent_name: request.agent_name,
-      scopes: request.scopes || ["create_payments"],
-      rate_limit_per_hour: request.rate_limit_per_hour || 1e3,
-      metadata: request.metadata
+  async createPayment(request) {
+    return this.request("POST", "/api/v1/payments", {
+      ...request,
+      currency: request.currency || "USD",
+      token: request.token || "USDC"
     });
   }
   /**
-   * List all agent API keys for the merchant
-   * 
-   * @returns Array of agent API keys (without full_key for security)
-   * 
-   * @example
-   * ```typescript
-   * const keys = await zendfi.agent.listKeys();
-   * keys.forEach(key => {
-   *   console.log(`${key.name}: ${key.key_prefix}*** (${key.scopes.join(', ')})`);
-   * });
-   * ```
+   * Get payment by ID
    */
-  async listKeys() {
-    const response = await this.request(
-      "GET",
-      "/api/v1/agent-keys"
-    );
-    return normalizeArrayResponse(response, "keys");
+  async getPayment(paymentId) {
+    return this.request("GET", `/api/v1/payments/${paymentId}`);
   }
   /**
-   * Revoke an agent API key
-   * 
-   * Once revoked, the key cannot be used for any API calls.
-   * This action is irreversible.
-   * 
-   * @param keyId - UUID of the agent key to revoke
-   * 
-   * @example
-   * ```typescript
-   * await zendfi.agent.revokeKey('ak_123...');
-   * console.log('Agent key revoked');
-   * ```
+   * Create a subscription plan
    */
-  async revokeKey(keyId) {
-    await this.request("POST", `/api/v1/agent-keys/${keyId}/revoke`);
+  async createSubscriptionPlan(request) {
+    return this.request("POST", "/api/v1/subscriptions/plans", {
+      ...request,
+      currency: request.currency || "USD",
+      interval_count: request.interval_count || 1,
+      trial_days: request.trial_days || 0
+    });
   }
-  // ============================================
-  // Agent Sessions
-  // ============================================
   /**
-   * Create an agent session with spending limits
-   * 
-   * Sessions provide time-bounded authorization for agents to make payments
-   * on behalf of users, with configurable spending limits.
-   * 
-   * @param request - Session configuration
-   * @returns The created session with token
-   * 
-   * @example
-   * ```typescript
-   * const session = await zendfi.agent.createSession({
-   *   agent_id: 'shopping-assistant-v1',
-   *   agent_name: 'Shopping Assistant',
-   *   user_wallet: 'Hx7B...abc',
-   *   limits: {
-   *     max_per_transaction: 100,
-   *     max_per_day: 500,
-   *     require_approval_above: 50,
-   *   },
-   *   duration_hours: 24,
-   * });
-   * 
-   * // Use session_token for subsequent API calls
-   * console.log(session.session_token); // => "zai_session_..."
-   * ```
+   * Get subscription plan by ID
    */
-  async createSession(request) {
-    return this.request("POST", "/api/v1/ai/sessions", {
-      agent_id: request.agent_id,
-      agent_name: request.agent_name,
-      user_wallet: request.user_wallet,
-      limits: request.limits || {
-        max_per_transaction: 1e3,
-        max_per_day: 5e3,
-        max_per_week: 2e4,
-        max_per_month: 5e4,
-        require_approval_above: 500
-      },
-      allowed_merchants: request.allowed_merchants,
-      duration_hours: request.duration_hours || 24,
-      mint_pkp: request.mint_pkp,
-      metadata: request.metadata
-    });
+  async getSubscriptionPlan(planId) {
+    return this.request("GET", `/api/v1/subscriptions/plans/${planId}`);
   }
   /**
-   * List all agent sessions
-   * 
-   * @returns Array of agent sessions (both active and expired)
-   * 
-   * @example
-   * ```typescript
-   * const sessions = await zendfi.agent.listSessions();
-   * const activeSessions = sessions.filter(s => s.is_active);
-   * console.log(`${activeSessions.length} active sessions`);
-   * ```
+   * Create a subscription
    */
-  async listSessions() {
-    const response = await this.request(
-      "GET",
-      "/api/v1/ai/sessions"
-    );
-    return normalizeArrayResponse(response, "sessions");
+  async createSubscription(request) {
+    return this.request("POST", "/api/v1/subscriptions", request);
   }
   /**
-   * Get a specific agent session by ID
-   * 
-   * @param sessionId - UUID of the session
-   * @returns The session details with remaining limits
-   * 
-   * @example
-   * ```typescript
-   * const session = await zendfi.agent.getSession('sess_123...');
-   * console.log(`Remaining today: $${session.remaining_today}`);
-   * console.log(`Expires: ${session.expires_at}`);
-   * ```
+   * Get subscription by ID
    */
-  async getSession(sessionId) {
-    return this.request("GET", `/api/v1/ai/sessions/${sessionId}`);
+  async getSubscription(subscriptionId) {
+    return this.request("GET", `/api/v1/subscriptions/${subscriptionId}`);
   }
   /**
-   * Revoke an agent session
-   * 
-   * Immediately invalidates the session, preventing any further payments.
-   * This action is irreversible.
-   * 
-   * @param sessionId - UUID of the session to revoke
-   * 
-   * @example
-   * ```typescript
-   * await zendfi.agent.revokeSession('sess_123...');
-   * console.log('Session revoked - agent can no longer make payments');
-   * ```
+   * Cancel a subscription
    */
-  async revokeSession(sessionId) {
-    await this.request("POST", `/api/v1/ai/sessions/${sessionId}/revoke`);
+  async cancelSubscription(subscriptionId) {
+    return this.request(
+      "POST",
+      `/api/v1/subscriptions/${subscriptionId}/cancel`
+    );
   }
-  // ============================================
-  // Agent Payments
-  // ============================================
   /**
-   * Execute a payment using an agent session
-   * 
-   * This is the primary method for AI agents to make payments. It uses the
-   * session token to enforce spending limits and automatically routes the
-   * payment through the optimal path.
-   * 
-   * The session token comes from `createSession()` and enforces:
-   * - Per-transaction limits
-   * - Daily limits
-   * - Weekly limits
-   * - Monthly limits
-   * 
-   * @param request - Payment request with session token
-   * @returns Payment result with status and receipt
-   * 
-   * @example
-   * ```typescript
-   * // Create a session first
-   * const session = await zendfi.agent.createSession({
-   *   agent_id: 'shopping-bot',
-   *   user_wallet: 'Hx7B...abc',
-   *   limits: {
-   *     max_per_transaction: 50,
-   *     max_per_day: 200,
-   *   },
-   *   duration_hours: 24,
-   * });
-   * 
-   * // Make payments within the session limits
-   * const payment = await zendfi.agent.pay({
-   *   session_token: session.session_token,
-   *   amount: 29.99,
-   *   description: 'Premium widget',
-   *   auto_gasless: true,
-   * });
-   * 
-   * if (payment.requires_signature) {
-   *   // Device-bound: user must sign
-   *   console.log('Sign and submit to:', payment.submit_url);
-   * } else {
-   *   // Auto-signed: payment complete
-   *   console.log('Payment confirmed:', payment.transaction_signature);
-   * }
-   * ```
+   * Create a payment link (shareable checkout URL)
    */
-  async pay(request) {
-    return this.request("POST", "/api/v1/ai/smart-payment", {
-      session_token: request.session_token,
-      agent_id: "session",
-      // Session already has agent_id bound
-      user_wallet: "",
-      // Will be extracted from session
-      amount_usd: request.amount,
-      merchant_id: request.recipient_merchant_id,
+  async createPaymentLink(request) {
+    const response = await this.request("POST", "/api/v1/payment-links", {
+      ...request,
+      currency: request.currency || "USD",
       token: request.token || "USDC",
-      auto_detect_gasless: request.auto_gasless,
-      description: request.description,
-      metadata: request.metadata
+      onramp: request.onramp || false
     });
+    return {
+      ...response,
+      url: response.hosted_page_url
+    };
   }
-  // ============================================
-  // Agent Analytics
-  // ============================================
   /**
-   * Get analytics for all agent activity
-   * 
-   * @returns Comprehensive analytics including payments, success rate, and PPP savings
-   * 
-   * @example
-   * ```typescript
-   * const analytics = await zendfi.agent.getAnalytics();
-   * console.log(`Total volume: $${analytics.total_volume_usd}`);
-   * console.log(`Success rate: ${(analytics.success_rate * 100).toFixed(1)}%`);
-   * console.log(`PPP savings: $${analytics.ppp_savings_usd}`);
-   * ```
+   * Get payment link by link code
    */
-  async getAnalytics() {
-    return this.request("GET", "/api/v1/analytics/agents");
+  async getPaymentLink(linkCode) {
+    const response = await this.request("GET", `/api/v1/payment-links/${linkCode}`);
+    return {
+      ...response,
+      url: response.hosted_page_url
+    };
   }
-};
-
-// src/aip/intents.ts
-var PaymentIntentsAPI = class {
-  constructor(request) {
-    this.request = request;
+  /**
+   * List all payment links for the authenticated merchant
+   */
+  async listPaymentLinks() {
+    const response = await this.request("GET", "/api/v1/payment-links");
+    return response.map((link) => ({
+      ...link,
+      url: link.hosted_page_url
+    }));
   }
   /**
-   * Create a payment intent
-   * 
-   * This is step 1 of the two-phase payment flow. The intent reserves
-   * the payment amount and provides a client_secret for confirmation.
-   * 
-   * @param request - Payment intent configuration
-   * @returns The created payment intent with client_secret
-   * 
-   * @example
-   * ```typescript
-   * const intent = await zendfi.intents.create({
-   *   amount: 49.99,
-   *   description: 'Pro Plan - Monthly',
-   *   capture_method: 'automatic', // or 'manual' for auth-only
-   *   expires_in_seconds: 3600, // 1 hour
-   * });
-   * 
-   * // Store intent.id and pass intent.client_secret to frontend
-   * console.log(`Intent created: ${intent.id}`);
-   * console.log(`Status: ${intent.status}`); // "requires_payment"
-   * ```
+   * Create an installment plan
+   * Split a purchase into multiple scheduled payments
    */
-  async create(request) {
-    return this.request("POST", "/api/v1/payment-intents", {
-      amount: request.amount,
-      currency: request.currency || "USD",
-      description: request.description,
-      capture_method: request.capture_method || "automatic",
-      agent_id: request.agent_id,
-      agent_name: request.agent_name,
-      metadata: request.metadata,
-      expires_in_seconds: request.expires_in_seconds || 86400
-      // 24h default
-    });
+  async createInstallmentPlan(request) {
+    const response = await this.request(
+      "POST",
+      "/api/v1/installment-plans",
+      request
+    );
+    return {
+      id: response.plan_id,
+      plan_id: response.plan_id,
+      status: response.status
+    };
   }
   /**
-   * Get a payment intent by ID
-   * 
-   * @param intentId - UUID of the payment intent
-   * @returns The payment intent details
-   * 
-   * @example
-   * ```typescript
-   * const intent = await zendfi.intents.get('pi_123...');
-   * console.log(`Status: ${intent.status}`);
-   * if (intent.payment_id) {
-   *   console.log(`Payment: ${intent.payment_id}`);
-   * }
-   * ```
+   * Get installment plan by ID
    */
-  async get(intentId) {
-    return this.request("GET", `/api/v1/payment-intents/${intentId}`);
-  }
-  /**
-   * List payment intents
-   * 
-   * @param options - Filter and pagination options
-   * @returns Array of payment intents
-   * 
-   * @example
-   * ```typescript
-   * // Get recent pending intents
-   * const intents = await zendfi.intents.list({
-   *   status: 'requires_payment',
-   *   limit: 20,
-   * });
-   * ```
-   */
-  async list(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.append("status", options.status);
-    if (options?.limit) params.append("limit", options.limit.toString());
-    if (options?.offset) params.append("offset", options.offset.toString());
-    const query = params.toString() ? `?${params.toString()}` : "";
-    const response = await this.request(
-      "GET",
-      `/api/v1/payment-intents${query}`
-    );
-    return Array.isArray(response) ? response : response.intents;
-  }
-  /**
-   * Confirm a payment intent
-   * 
-   * This is step 2 of the two-phase payment flow. Confirmation triggers
-   * the actual payment using the customer's wallet.
-   * 
-   * @param intentId - UUID of the payment intent
-   * @param request - Confirmation details including customer wallet
-   * @returns The confirmed payment intent with payment_id
-   * 
-   * @example
-   * ```typescript
-   * const confirmed = await zendfi.intents.confirm('pi_123...', {
-   *   client_secret: 'pi_secret_abc...',
-   *   customer_wallet: 'Hx7B...abc',
-   *   auto_gasless: true,
-   * });
-   * 
-   * if (confirmed.status === 'succeeded') {
-   *   console.log(`Payment complete: ${confirmed.payment_id}`);
-   * }
-   * ```
-   */
-  async confirm(intentId, request) {
-    return this.request("POST", `/api/v1/payment-intents/${intentId}/confirm`, {
-      client_secret: request.client_secret,
-      customer_wallet: request.customer_wallet,
-      payment_type: request.payment_type,
-      auto_gasless: request.auto_gasless,
-      metadata: request.metadata,
-      session_token: request.session_token
-    });
-  }
-  /**
-   * Cancel a payment intent
-   * 
-   * Canceling releases any hold on the payment amount. Cannot cancel
-   * intents that are already processing or succeeded.
-   * 
-   * @param intentId - UUID of the payment intent
-   * @returns The canceled payment intent
-   * 
-   * @example
-   * ```typescript
-   * const canceled = await zendfi.intents.cancel('pi_123...');
-   * console.log(`Status: ${canceled.status}`); // "canceled"
-   * ```
-   */
-  async cancel(intentId) {
-    return this.request("POST", `/api/v1/payment-intents/${intentId}/cancel`);
-  }
-  /**
-   * Get events for a payment intent
-   * 
-   * Events track the full lifecycle of the intent, including creation,
-   * confirmation attempts, and status changes.
-   * 
-   * @param intentId - UUID of the payment intent
-   * @returns Array of events in chronological order
-   * 
-   * @example
-   * ```typescript
-   * const events = await zendfi.intents.getEvents('pi_123...');
-   * events.forEach(event => {
-   *   console.log(`${event.created_at}: ${event.event_type}`);
-   * });
-   * ```
-   */
-  async getEvents(intentId) {
-    const response = await this.request(
-      "GET",
-      `/api/v1/payment-intents/${intentId}/events`
-    );
-    return Array.isArray(response) ? response : response.events;
-  }
-};
-
-// src/aip/pricing.ts
-var PricingAPI = class {
-  constructor(request) {
-    this.request = request;
-  }
-  /**
-   * Get PPP factor for a specific country
-   * 
-   * Returns the purchasing power parity adjustment factor for the given
-   * country code. Use this to calculate localized pricing.
-   * 
-   * @param countryCode - ISO 3166-1 alpha-2 country code (e.g., "BR", "IN", "NG")
-   * @returns PPP factor and suggested adjustment
-   * 
-   * @example
-   * ```typescript
-   * const factor = await zendfi.pricing.getPPPFactor('BR');
-   * // {
-   * //   country_code: 'BR',
-   * //   country_name: 'Brazil',
-   * //   ppp_factor: 0.35,
-   * //   currency_code: 'BRL',
-   * //   adjustment_percentage: 35.0
-   * // }
-   * 
-   * // Calculate localized price
-   * const usdPrice = 100;
-   * const localPrice = usdPrice * (1 - factor.adjustment_percentage / 100);
-   * console.log(`$${localPrice} for Brazilian customers`);
-   * ```
-   */
-  async getPPPFactor(countryCode) {
-    return this.request("POST", "/api/v1/ai/pricing/ppp-factor", {
-      country_code: countryCode.toUpperCase()
-    });
-  }
-  /**
-   * List all available PPP factors
-   * 
-   * Returns PPP factors for all supported countries. Useful for building
-   * pricing tables or pre-computing regional prices.
-   * 
-   * @returns Array of PPP factors for all supported countries
-   * 
-   * @example
-   * ```typescript
-   * const factors = await zendfi.pricing.listFactors();
-   * 
-   * // Create pricing tiers
-   * const tiers = factors.map(f => ({
-   *   country: f.country_name,
-   *   price: (100 * f.ppp_factor).toFixed(2),
-   * }));
-   * 
-   * console.table(tiers);
-   * ```
-   */
-  async listFactors() {
-    const response = await this.request(
-      "GET",
-      "/api/v1/ai/pricing/ppp-factors"
-    );
-    return Array.isArray(response) ? response : response.factors;
-  }
-  /**
-   * Get AI-powered pricing suggestion
-   * 
-   * Returns an intelligent pricing recommendation based on the user's
-   * location, wallet history, and your pricing configuration.
-   * 
-   * @param request - Pricing suggestion request with user context
-   * @returns AI-generated pricing suggestion with reasoning
-   * 
-   * @example
-   * ```typescript
-   * const suggestion = await zendfi.pricing.getSuggestion({
-   *   agent_id: 'shopping-assistant',
-   *   base_price: 99.99,
-   *   user_profile: {
-   *     location_country: 'BR',
-   *     context: 'first-time',
-   *   },
-   *   ppp_config: {
-   *     enabled: true,
-   *     max_discount_percent: 50,
-   *     floor_price: 29.99,
-   *   },
-   * });
-   * 
-   * console.log(`Suggested: $${suggestion.suggested_amount}`);
-   * console.log(`Reason: ${suggestion.reasoning}`);
-   * // => "Price adjusted for Brazilian purchasing power (35% PPP discount) 
-   * //     plus 10% first-time customer discount"
-   * ```
-   */
-  async getSuggestion(request) {
-    return this.request("POST", "/api/v1/ai/pricing/suggest", {
-      agent_id: request.agent_id,
-      product_id: request.product_id,
-      base_price: request.base_price,
-      currency: request.currency || "USD",
-      user_profile: request.user_profile,
-      ppp_config: request.ppp_config
-    });
-  }
-  /**
-   * Calculate localized price for a given base price and country
-   * 
-   * Convenience method that combines getPPPFactor with price calculation.
-   * 
-   * @param basePrice - Original price in USD
-   * @param countryCode - ISO 3166-1 alpha-2 country code
-   * @returns Object with original and adjusted prices
-   * 
-   * @example
-   * ```typescript
-   * const result = await zendfi.pricing.calculateLocalPrice(100, 'IN');
-   * console.log(`Original: $${result.original}`);
-   * console.log(`Local: $${result.adjusted}`);
-   * console.log(`Savings: $${result.savings} (${result.discount_percentage}%)`);
-   * ```
-   */
-  async calculateLocalPrice(basePrice, countryCode) {
-    const factor = await this.getPPPFactor(countryCode);
-    const adjusted = Number((basePrice * factor.ppp_factor).toFixed(2));
-    const savings = Number((basePrice - adjusted).toFixed(2));
-    return {
-      original: basePrice,
-      adjusted,
-      savings,
-      discount_percentage: factor.adjustment_percentage,
-      country: factor.country_name,
-      ppp_factor: factor.ppp_factor
-    };
-  }
-};
-
-// src/aip/autonomy.ts
-var AutonomyAPI = class {
-  constructor(request) {
-    this.request = request;
-  }
-  /**
-   * Enable autonomous signing for a session key
-   * 
-   * This grants an AI agent the ability to sign transactions on behalf of
-   * the user, up to the specified spending limit and duration.
-   * 
-   * **Prerequisites:**
-   * 1. Create a device-bound session key first
-   * 2. Generate a delegation signature (see `createDelegationMessage`)
-   * 3. Optionally encrypt keypair with Lit Protocol for true autonomy
-   * 
-   * @param sessionKeyId - UUID of the session key
-   * @param request - Autonomy configuration including delegation signature
-   * @returns The created autonomous delegate
-   * 
-   * @example
-   * ```typescript
-   * // The user must sign this exact message format
-   * const message = zendfi.autonomy.createDelegationMessage(
-   *   sessionKeyId, 100, '2024-12-10T00:00:00Z'
-   * );
-   * 
-   * // Have user sign with their session key
-   * const signature = await signWithSessionKey(message, pin);
-   * 
-   * // Enable autonomous mode
-   * const delegate = await zendfi.autonomy.enable(sessionKeyId, {
-   *   max_amount_usd: 100,
-   *   duration_hours: 24,
-   *   delegation_signature: signature,
-   * });
-   * 
-   * console.log(`Delegate ID: ${delegate.delegate_id}`);
-   * console.log(`Expires: ${delegate.expires_at}`);
-   * ```
-   */
-  async enable(sessionKeyId, request) {
-    return this.request(
-      "POST",
-      `/api/v1/ai/session-keys/${sessionKeyId}/enable-autonomy`,
-      {
-        max_amount_usd: request.max_amount_usd,
-        duration_hours: request.duration_hours,
-        delegation_signature: request.delegation_signature,
-        expires_at: request.expires_at,
-        lit_encrypted_keypair: request.lit_encrypted_keypair,
-        lit_data_hash: request.lit_data_hash,
-        metadata: request.metadata
-      }
-    );
-  }
-  /**
-   * Revoke autonomous mode for a session key
-   * 
-   * Immediately invalidates the autonomous delegate, preventing any further
-   * automatic payments. The session key itself remains valid for manual use.
-   * 
-   * @param sessionKeyId - UUID of the session key
-   * @param reason - Optional reason for revocation (logged for audit)
-   * 
-   * @example
-   * ```typescript
-   * await zendfi.autonomy.revoke('sk_123...', 'User requested revocation');
-   * console.log('Autonomous mode disabled');
-   * ```
-   */
-  async revoke(sessionKeyId, reason) {
-    const request = { reason };
-    await this.request(
-      "POST",
-      `/api/v1/ai/session-keys/${sessionKeyId}/revoke-autonomy`,
-      request
-    );
-  }
-  /**
-   * Get autonomy status for a session key
-   * 
-   * Returns whether autonomous mode is enabled and details about the
-   * active delegate including remaining spending allowance.
-   * 
-   * @param sessionKeyId - UUID of the session key
-   * @returns Autonomy status with delegate details
-   * 
-   * @example
-   * ```typescript
-   * const status = await zendfi.autonomy.getStatus('sk_123...');
-   * 
-   * if (status.autonomous_mode_enabled && status.delegate) {
-   *   console.log(`Remaining: $${status.delegate.remaining_usd}`);
-   *   console.log(`Expires: ${status.delegate.expires_at}`);
-   * } else {
-   *   console.log('Autonomous mode not enabled');
-   * }
-   * ```
-   */
-  async getStatus(sessionKeyId) {
-    return this.request(
-      "GET",
-      `/api/v1/ai/session-keys/${sessionKeyId}/autonomy-status`
-    );
-  }
-  /**
-   * Create the delegation message that needs to be signed
-   * 
-   * This generates the exact message format required for the delegation
-   * signature. The user must sign this message with their session key.
-   * 
-   * **Message format:**
-   * ```
-   * I authorize autonomous delegate for session {id} to spend up to ${amount} until {expiry}
-   * ```
-   * 
-   * @param sessionKeyId - UUID of the session key
-   * @param maxAmountUsd - Maximum spending amount in USD
-   * @param expiresAt - ISO 8601 expiration timestamp
-   * @returns The message to be signed
-   * 
-   * @example
-   * ```typescript
-   * const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
-   * const message = zendfi.autonomy.createDelegationMessage(
-   *   'sk_123...',
-   *   100,
-   *   expiresAt
-   * );
-   * // => "I authorize autonomous delegate for session sk_123... to spend up to $100 until 2024-12-06T..."
-   * 
-   * // Sign with nacl.sign.detached() or similar
-   * const signature = signMessage(message, keypair);
-   * ```
-   */
-  createDelegationMessage(sessionKeyId, maxAmountUsd, expiresAt) {
-    return `I authorize autonomous delegate for session ${sessionKeyId} to spend up to $${maxAmountUsd} until ${expiresAt}`;
-  }
-  /**
-   * Validate delegation signature parameters
-   * 
-   * Helper method to check if autonomy parameters are valid before
-   * making the API call.
-   * 
-   * @param request - The enable autonomy request to validate
-   * @throws Error if validation fails
-   * 
-   * @example
-   * ```typescript
-   * try {
-   *   zendfi.autonomy.validateRequest(request);
-   *   const delegate = await zendfi.autonomy.enable(sessionKeyId, request);
-   * } catch (error) {
-   *   console.error('Invalid request:', error.message);
-   * }
-   * ```
-   */
-  validateRequest(request) {
-    if (request.max_amount_usd <= 0) {
-      throw new Error("max_amount_usd must be positive");
-    }
-    if (request.duration_hours < 1 || request.duration_hours > 168) {
-      throw new Error("duration_hours must be between 1 and 168 (7 days)");
-    }
-    if (!request.delegation_signature || request.delegation_signature.length === 0) {
-      throw new Error("delegation_signature is required");
-    }
-    const base64Regex = /^[A-Za-z0-9+/]+=*$/;
-    if (!base64Regex.test(request.delegation_signature)) {
-      throw new Error("delegation_signature must be base64 encoded");
-    }
-  }
-  /**
-   * Get spending attestations for a delegate (audit trail)
-   * 
-   * Returns all cryptographically signed attestations ZendFi created for
-   * this delegate. Each attestation contains:
-   * - The spending state at the time of payment
-   * - ZendFi's Ed25519 signature
-   * - Timestamp and nonce (for replay protection)
-   * 
-   * These attestations can be independently verified using ZendFi's public key
-   * to confirm spending limit enforcement was applied correctly.
-   * 
-   * @param delegateId - UUID of the autonomous delegate
-   * @returns Attestation audit response with all signed attestations
-   * 
-   * @example
-   * ```typescript
-   * const audit = await zendfi.autonomy.getAttestations('delegate_123...');
-   * 
-   * console.log(`Found ${audit.attestation_count} attestations`);
-   * console.log(`ZendFi public key: ${audit.zendfi_attestation_public_key}`);
-   * 
-   * // Verify each attestation independently
-   * for (const signed of audit.attestations) {
-   *   console.log(`Payment ${signed.attestation.payment_id}:`);
-   *   console.log(`  Requested: $${signed.attestation.requested_usd}`);
-   *   console.log(`  Remaining after: $${signed.attestation.remaining_after_usd}`);
-   *   // Verify signature with nacl.sign.detached.verify()
-   * }
-   * ```
-   */
-  async getAttestations(delegateId) {
-    return this.request(
-      "GET",
-      `/api/v1/ai/delegates/${delegateId}/attestations`
-    );
-  }
-};
-
-// src/aip/smart-payments.ts
-var SmartPaymentsAPI = class {
-  constructor(request) {
-    this.request = request;
-  }
-  /**
-   * Execute an AI-powered smart payment
-   * 
-   * Smart payments analyze the context and automatically apply optimizations:
-   * - **PPP Pricing**: Auto-adjusts based on customer location
-   * - **Gasless**: Detects when user needs gas subsidization
-   * - **Instant Settlement**: Optional immediate merchant payout
-   * - **Escrow**: Optional fund holding for service delivery
-   * 
-   * @param request - Smart payment request configuration
-   * @returns Payment result with status and receipt
-   * 
-   * @example
-   * ```typescript
-   * // Basic smart payment
-   * const result = await zendfi.payments.smart({
-   *   agent_id: 'my-agent',
-   *   user_wallet: 'Hx7B...abc',
-   *   amount_usd: 99.99,
-   *   description: 'Annual Pro Plan',
-   * });
-   * 
-   * // With all options
-   * const result = await zendfi.payments.smart({
-   *   agent_id: 'my-agent',
-   *   session_token: 'zai_session_...', // For limit enforcement
-   *   user_wallet: 'Hx7B...abc',
-   *   amount_usd: 99.99,
-   *   token: 'USDC',
-   *   auto_detect_gasless: true,
-   *   instant_settlement: true,
-   *   enable_escrow: false,
-   *   description: 'Annual Pro Plan',
-   *   product_details: {
-   *     name: 'Pro Plan',
-   *     sku: 'PRO-ANNUAL',
-   *   },
-   *   metadata: {
-   *     user_id: 'usr_123',
-   *   },
-   * });
-   * 
-   * if (result.requires_signature) {
-   *   // Device-bound flow: need user to sign
-   *   console.log('Please sign:', result.unsigned_transaction);
-   *   console.log('Submit to:', result.submit_url);
-   * } else {
-   *   // Auto-signed (custodial or autonomous delegate)
-   *   console.log('Payment complete:', result.transaction_signature);
-   * }
-   * ```
-   */
-  async execute(request) {
-    return this.request("POST", "/api/v1/ai/smart-payment", {
-      session_token: request.session_token,
-      agent_id: request.agent_id,
-      user_wallet: request.user_wallet,
-      amount_usd: request.amount_usd,
-      merchant_id: request.merchant_id,
-      token: request.token || "USDC",
-      auto_detect_gasless: request.auto_detect_gasless,
-      instant_settlement: request.instant_settlement,
-      enable_escrow: request.enable_escrow,
-      description: request.description,
-      product_details: request.product_details,
-      metadata: request.metadata
-    });
-  }
-  /**
-   * Submit a signed transaction from device-bound flow
-   * 
-   * When a smart payment returns `requires_signature: true`, the client
-   * must sign the transaction and submit it here.
-   * 
-   * @param paymentId - UUID of the payment
-   * @param signedTransaction - Base64 encoded signed transaction
-   * @returns Updated payment response
-   * 
-   * @example
-   * ```typescript
-   * // After user signs the transaction
-   * const result = await zendfi.payments.submitSigned(
-   *   payment.payment_id,
-   *   signedTransaction
-   * );
-   * 
-   * console.log(`Confirmed in ${result.confirmed_in_ms}ms`);
-   * ```
-   */
-  async submitSigned(paymentId, signedTransaction) {
-    return this.request(
-      "POST",
-      `/api/v1/ai/payments/${paymentId}/submit-signed`,
-      {
-        signed_transaction: signedTransaction
-      }
-    );
-  }
-};
-
-// src/device-bound-crypto.ts
-var import_web3 = require("@solana/web3.js");
-var crypto2 = __toESM(require("crypto"));
-var DeviceFingerprintGenerator = class {
-  /**
-   * Generate a unique device fingerprint
-   * Combines multiple browser attributes for uniqueness
-   */
-  static async generate() {
-    const components = {};
-    try {
-      components.canvas = await this.getCanvasFingerprint();
-      components.webgl = await this.getWebGLFingerprint();
-      components.audio = await this.getAudioFingerprint();
-      if (typeof screen !== "undefined") {
-        components.screen = `${screen.width}x${screen.height}x${screen.colorDepth}`;
-      } else {
-        components.screen = "unknown-ssr";
-      }
-      components.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-      if (typeof navigator !== "undefined") {
-        components.languages = navigator.languages?.join(",") || navigator.language;
-        components.platform = navigator.platform;
-        components.hardwareConcurrency = navigator.hardwareConcurrency?.toString() || "unknown";
-      } else {
-        components.languages = "unknown-ssr";
-        components.platform = "unknown-ssr";
-        components.hardwareConcurrency = "unknown-ssr";
-      }
-      const combined = Object.entries(components).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}:${value}`).join("|");
-      const fingerprint = await this.sha256(combined);
-      return {
-        fingerprint,
-        generatedAt: Date.now(),
-        components
-      };
-    } catch (error) {
-      console.warn("Device fingerprinting failed, using fallback", error);
-      return this.generateFallbackFingerprint();
-    }
-  }
-  /**
-   * Graceful fallback fingerprint generation
-   * Works in headless browsers, SSR, and restricted environments
-   */
-  static async generateFallbackFingerprint() {
-    const components = {};
-    try {
-      if (typeof navigator !== "undefined") {
-        components.platform = navigator.platform || "unknown";
-        components.languages = navigator.languages?.join(",") || navigator.language || "unknown";
-        components.hardwareConcurrency = navigator.hardwareConcurrency?.toString() || "unknown";
-      }
-      if (typeof screen !== "undefined") {
-        components.screen = `${screen.width || 0}x${screen.height || 0}x${screen.colorDepth || 0}`;
-      }
-      if (typeof Intl !== "undefined") {
-        try {
-          components.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        } catch {
-          components.timezone = "unknown";
-        }
-      }
-    } catch {
-      components.platform = "fallback";
-    }
-    let randomEntropy = "";
-    try {
-      if (typeof window !== "undefined" && window.crypto?.getRandomValues) {
-        const arr = new Uint8Array(16);
-        window.crypto.getRandomValues(arr);
-        randomEntropy = Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
-      } else if (typeof crypto2 !== "undefined" && crypto2.randomBytes) {
-        randomEntropy = crypto2.randomBytes(16).toString("hex");
-      }
-    } catch {
-      randomEntropy = Date.now().toString(36) + Math.random().toString(36);
-    }
-    const combined = Object.entries(components).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}:${value}`).join("|") + "|entropy:" + randomEntropy;
-    const fingerprint = await this.sha256(combined);
-    return {
-      fingerprint,
-      generatedAt: Date.now(),
-      components
-    };
-  }
-  static async getCanvasFingerprint() {
-    if (typeof document === "undefined") return "no-canvas-ssr";
-    const canvas = document.createElement("canvas");
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return "no-canvas";
-    canvas.width = 200;
-    canvas.height = 50;
-    ctx.textBaseline = "top";
-    ctx.font = '14px "Arial"';
-    ctx.fillStyle = "#f60";
-    ctx.fillRect(0, 0, 100, 50);
-    ctx.fillStyle = "#069";
-    ctx.fillText("ZendFi \u{1F510}", 2, 2);
-    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
-    ctx.fillText("Device-Bound", 4, 17);
-    return canvas.toDataURL();
-  }
-  static async getWebGLFingerprint() {
-    if (typeof document === "undefined") return "no-webgl-ssr";
-    const canvas = document.createElement("canvas");
-    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
-    if (!gl) return "no-webgl";
-    const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
-    if (!debugInfo) return "no-debug-info";
-    const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
-    const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
-    return `${vendor}|${renderer}`;
-  }
-  static async getAudioFingerprint() {
-    try {
-      if (typeof window === "undefined") return "no-audio-ssr";
-      const AudioContext = window.AudioContext || window.webkitAudioContext;
-      if (!AudioContext) return "no-audio";
-      const context = new AudioContext();
-      const oscillator = context.createOscillator();
-      const analyser = context.createAnalyser();
-      const gainNode = context.createGain();
-      const scriptProcessor = context.createScriptProcessor(4096, 1, 1);
-      gainNode.gain.value = 0;
-      oscillator.connect(analyser);
-      analyser.connect(scriptProcessor);
-      scriptProcessor.connect(gainNode);
-      gainNode.connect(context.destination);
-      oscillator.start(0);
-      return new Promise((resolve) => {
-        scriptProcessor.onaudioprocess = (event) => {
-          const output = event.inputBuffer.getChannelData(0);
-          const hash = Array.from(output.slice(0, 30)).reduce((acc, val) => acc + Math.abs(val), 0);
-          oscillator.stop();
-          scriptProcessor.disconnect();
-          context.close();
-          resolve(hash.toString());
-        };
-      });
-    } catch (error) {
-      return "audio-error";
-    }
-  }
-  static async sha256(data) {
-    if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
-      const encoder = new TextEncoder();
-      const dataBuffer = encoder.encode(data);
-      const hashBuffer = await window.crypto.subtle.digest("SHA-256", dataBuffer);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-    } else {
-      return crypto2.createHash("sha256").update(data).digest("hex");
-    }
-  }
-};
-var SessionKeyCrypto = class {
-  /**
-   * Encrypt a Solana keypair with PIN + device fingerprint
-   * Uses Argon2id for key derivation and AES-256-GCM for encryption
-   */
-  static async encrypt(keypair, pin, deviceFingerprint) {
-    if (!/^\d{6}$/.test(pin)) {
-      throw new Error("PIN must be exactly 6 numeric digits");
-    }
-    const encryptionKey = await this.deriveKey(pin, deviceFingerprint);
-    const nonce = this.generateNonce();
-    const secretKey = keypair.secretKey;
-    const encryptedData = await this.aesEncrypt(secretKey, encryptionKey, nonce);
-    return {
-      encryptedData: Buffer.from(encryptedData).toString("base64"),
-      nonce: Buffer.from(nonce).toString("base64"),
-      publicKey: keypair.publicKey.toBase58(),
-      deviceFingerprint,
-      version: "argon2id-aes256gcm-v1"
-    };
-  }
-  /**
-   * Decrypt an encrypted session key with PIN + device fingerprint
-   */
-  static async decrypt(encrypted, pin, deviceFingerprint) {
-    if (!/^\d{6}$/.test(pin)) {
-      throw new Error("PIN must be exactly 6 numeric digits");
-    }
-    if (encrypted.deviceFingerprint !== deviceFingerprint) {
-      throw new Error("Device fingerprint mismatch - wrong device or security threat");
-    }
-    const encryptionKey = await this.deriveKey(pin, deviceFingerprint);
-    const encryptedData = Buffer.from(encrypted.encryptedData, "base64");
-    const nonce = Buffer.from(encrypted.nonce, "base64");
-    try {
-      const secretKey = await this.aesDecrypt(encryptedData, encryptionKey, nonce);
-      return import_web3.Keypair.fromSecretKey(secretKey);
-    } catch (error) {
-      throw new Error("Decryption failed - wrong PIN or corrupted data");
-    }
-  }
-  /**
-   * Derive encryption key from PIN + device fingerprint using Argon2id
-   * 
-   * Argon2id parameters (OWASP recommended):
-   * - Memory: 64MB (65536 KB)
-   * - Iterations: 3
-   * - Parallelism: 4
-   * - Salt: device fingerprint
-   */
-  static async deriveKey(pin, deviceFingerprint) {
-    if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
-      const encoder = new TextEncoder();
-      const keyMaterial = await window.crypto.subtle.importKey(
-        "raw",
-        encoder.encode(pin),
-        { name: "PBKDF2" },
-        false,
-        ["deriveBits"]
-      );
-      const derivedBits = await window.crypto.subtle.deriveBits(
-        {
-          name: "PBKDF2",
-          salt: encoder.encode(deviceFingerprint),
-          iterations: 1e5,
-          // High iteration count for security
-          hash: "SHA-256"
-        },
-        keyMaterial,
-        256
-        // 256 bits = 32 bytes for AES-256
-      );
-      return new Uint8Array(derivedBits);
-    } else {
-      const salt = crypto2.createHash("sha256").update(deviceFingerprint).digest();
-      return crypto2.pbkdf2Sync(pin, salt, 1e5, 32, "sha256");
-    }
-  }
-  /**
-   * Generate random nonce for AES-GCM (12 bytes)
-   */
-  static generateNonce() {
-    if (typeof window !== "undefined" && window.crypto) {
-      return window.crypto.getRandomValues(new Uint8Array(12));
-    } else {
-      return crypto2.randomBytes(12);
-    }
-  }
-  /**
-   * Encrypt with AES-256-GCM
-   */
-  static async aesEncrypt(plaintext, key, nonce) {
-    if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
-      const keyBuffer = key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength);
-      const nonceBuffer = nonce.buffer.slice(nonce.byteOffset, nonce.byteOffset + nonce.byteLength);
-      const plaintextBuffer = plaintext.buffer.slice(plaintext.byteOffset, plaintext.byteOffset + plaintext.byteLength);
-      const cryptoKey = await window.crypto.subtle.importKey(
-        "raw",
-        keyBuffer,
-        { name: "AES-GCM" },
-        false,
-        ["encrypt"]
-      );
-      const encrypted = await window.crypto.subtle.encrypt(
-        {
-          name: "AES-GCM",
-          iv: nonceBuffer
-        },
-        cryptoKey,
-        plaintextBuffer
-      );
-      return new Uint8Array(encrypted);
-    } else {
-      const cipher = crypto2.createCipheriv("aes-256-gcm", key, nonce);
-      const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-      const authTag = cipher.getAuthTag();
-      return new Uint8Array(Buffer.concat([encrypted, authTag]));
-    }
-  }
-  /**
-   * Decrypt with AES-256-GCM
-   */
-  static async aesDecrypt(ciphertext, key, nonce) {
-    if (typeof window !== "undefined" && window.crypto && window.crypto.subtle) {
-      const keyBuffer = key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength);
-      const nonceBuffer = nonce.buffer.slice(nonce.byteOffset, nonce.byteOffset + nonce.byteLength);
-      const ciphertextBuffer = ciphertext.buffer.slice(ciphertext.byteOffset, ciphertext.byteOffset + ciphertext.byteLength);
-      const cryptoKey = await window.crypto.subtle.importKey(
-        "raw",
-        keyBuffer,
-        { name: "AES-GCM" },
-        false,
-        ["decrypt"]
-      );
-      const decrypted = await window.crypto.subtle.decrypt(
-        {
-          name: "AES-GCM",
-          iv: nonceBuffer
-        },
-        cryptoKey,
-        ciphertextBuffer
-      );
-      return new Uint8Array(decrypted);
-    } else {
-      const authTag = ciphertext.slice(-16);
-      const encrypted = ciphertext.slice(0, -16);
-      const decipher = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
-      decipher.setAuthTag(authTag);
-      const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-      return new Uint8Array(decrypted);
-    }
-  }
-};
-var RecoveryQRGenerator = class {
-  /**
-   * Generate recovery QR data
-   * This allows users to recover their session key on a new device
-   */
-  static generate(encrypted) {
-    return {
-      encryptedSessionKey: encrypted.encryptedData,
-      nonce: encrypted.nonce,
-      publicKey: encrypted.publicKey,
-      version: "v1",
-      createdAt: Date.now()
-    };
-  }
-  /**
-   * Encode recovery QR as JSON string
-   */
-  static encode(recoveryQR) {
-    return JSON.stringify(recoveryQR);
-  }
-  /**
-   * Decode recovery QR from JSON string
-   */
-  static decode(qrData) {
-    try {
-      const parsed = JSON.parse(qrData);
-      if (!parsed.encryptedSessionKey || !parsed.nonce || !parsed.publicKey) {
-        throw new Error("Invalid recovery QR data");
-      }
-      return parsed;
-    } catch (error) {
-      throw new Error("Failed to decode recovery QR");
-    }
-  }
-  /**
-   * Re-encrypt session key for new device
-   */
-  static async reEncryptForNewDevice(recoveryQR, oldPin, oldDeviceFingerprint, newPin, newDeviceFingerprint) {
-    const oldEncrypted = {
-      encryptedData: recoveryQR.encryptedSessionKey,
-      nonce: recoveryQR.nonce,
-      publicKey: recoveryQR.publicKey,
-      deviceFingerprint: oldDeviceFingerprint,
-      version: "argon2id-aes256gcm-v1"
-    };
-    const keypair = await SessionKeyCrypto.decrypt(oldEncrypted, oldPin, oldDeviceFingerprint);
-    return await SessionKeyCrypto.encrypt(keypair, newPin, newDeviceFingerprint);
-  }
-};
-var DeviceBoundSessionKey = class _DeviceBoundSessionKey {
-  encrypted = null;
-  deviceFingerprint = null;
-  sessionKeyId = null;
-  recoveryQR = null;
-  originalKeypair = null;
-  // Store for Lit encryption
-  // Auto-signing cache: decrypted keypair stored in memory
-  // Enables instant signing without re-entering PIN for subsequent payments
-  cachedKeypair = null;
-  cacheExpiry = null;
-  // Timestamp when cache expires
-  DEFAULT_CACHE_TTL_MS = 30 * 60 * 1e3;
-  // 30 minutes
-  /**
-   * Create a new device-bound session key
-   */
-  static async create(options) {
-    const deviceFingerprint = await DeviceFingerprintGenerator.generate();
-    const keypair = import_web3.Keypair.generate();
-    const encrypted = await SessionKeyCrypto.encrypt(
-      keypair,
-      options.pin,
-      deviceFingerprint.fingerprint
-    );
-    const instance = new _DeviceBoundSessionKey();
-    instance.encrypted = encrypted;
-    instance.deviceFingerprint = deviceFingerprint;
-    instance.originalKeypair = keypair;
-    if (options.generateRecoveryQR) {
-      instance.recoveryQR = RecoveryQRGenerator.generate(encrypted);
-    }
-    return instance;
-  }
-  /**
-   * Get the original keypair (only available immediately after creation)
-   * Used for Lit Protocol encryption during session creation
-   * @internal
-   */
-  getKeypair() {
-    if (!this.originalKeypair) {
-      throw new Error("Keypair not available - only accessible during session creation");
-    }
-    return this.originalKeypair;
-  }
-  /**
-   * Get encrypted data for backend storage
-   */
-  getEncryptedData() {
-    if (!this.encrypted) {
-      throw new Error("Session key not created yet");
-    }
-    return this.encrypted;
-  }
-  /**
-   * Get device fingerprint
-   */
-  getDeviceFingerprint() {
-    if (!this.deviceFingerprint) {
-      throw new Error("Device fingerprint not generated yet");
-    }
-    return this.deviceFingerprint.fingerprint;
-  }
-  /**
-   * Get public key
-   */
-  getPublicKey() {
-    if (!this.encrypted) {
-      throw new Error("Session key not created yet");
-    }
-    return this.encrypted.publicKey;
-  }
-  /**
-   * Get recovery QR data (if generated)
-   */
-  getRecoveryQR() {
-    return this.recoveryQR;
-  }
-  /**
-   * Decrypt and sign a transaction
-   * 
-   * @param transaction - The transaction to sign
-   * @param pin - User's PIN (required only if keypair not cached)
-   * @param cacheKeypair - Whether to cache the decrypted keypair for future use (default: true)
-   * @param cacheTTL - Cache time-to-live in milliseconds (default: 30 minutes)
-   * 
-   * @example
-   * ```typescript
-   * // First payment: requires PIN, caches keypair
-   * await sessionKey.signTransaction(tx1, '123456', true);
-   * 
-   * // Subsequent payments: uses cached keypair, no PIN needed!
-   * await sessionKey.signTransaction(tx2, '', false); // PIN ignored if cached
-   * 
-   * // Clear cache when done
-   * sessionKey.clearCache();
-   * ```
-   */
-  async signTransaction(transaction, pin = "", cacheKeypair = true, cacheTTL) {
-    if (!this.encrypted || !this.deviceFingerprint) {
-      throw new Error("Session key not initialized");
-    }
-    let keypair;
-    if (this.isCached()) {
-      keypair = this.cachedKeypair;
-    } else {
-      if (!pin) {
-        throw new Error("PIN required: no cached keypair available");
-      }
-      keypair = await SessionKeyCrypto.decrypt(
-        this.encrypted,
-        pin,
-        this.deviceFingerprint.fingerprint
-      );
-      if (cacheKeypair) {
-        const ttl = cacheTTL || this.DEFAULT_CACHE_TTL_MS;
-        this.cacheKeypair(keypair, ttl);
-      }
-    }
-    transaction.partialSign(keypair);
-    return transaction;
-  }
-  /**
-   * Check if keypair is cached and valid
-   */
-  isCached() {
-    if (!this.cachedKeypair || !this.cacheExpiry) {
-      return false;
-    }
-    const now = Date.now();
-    if (now > this.cacheExpiry) {
-      this.clearCache();
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Manually cache a keypair
-   * Called internally after PIN decryption
-   */
-  cacheKeypair(keypair, ttl) {
-    this.cachedKeypair = keypair;
-    this.cacheExpiry = Date.now() + ttl;
-  }
-  /**
-   * Clear cached keypair
-   * Should be called when user logs out or session ends
-   * 
-   * @example
-   * ```typescript
-   * // Clear cache on logout
-   * sessionKey.clearCache();
-   * 
-   * // Or clear automatically on tab close
-   * window.addEventListener('beforeunload', () => {
-   *   sessionKey.clearCache();
-   * });
-   * ```
-   */
-  clearCache() {
-    this.cachedKeypair = null;
-    this.cacheExpiry = null;
-  }
-  /**
-   * Decrypt and cache keypair without signing a transaction
-   * Useful for pre-warming the cache before user makes payments
-   * 
-   * @example
-   * ```typescript
-   * // After session key creation, decrypt and cache
-   * await sessionKey.unlockWithPin('123456');
-   * 
-   * // Now all subsequent payments are instant (no PIN)
-   * await sessionKey.signTransaction(tx1, '', false); // Instant!
-   * await sessionKey.signTransaction(tx2, '', false); // Instant!
-   * ```
-   */
-  async unlockWithPin(pin, cacheTTL) {
-    if (!this.encrypted || !this.deviceFingerprint) {
-      throw new Error("Session key not initialized");
-    }
-    const keypair = await SessionKeyCrypto.decrypt(
-      this.encrypted,
-      pin,
-      this.deviceFingerprint.fingerprint
-    );
-    const ttl = cacheTTL || this.DEFAULT_CACHE_TTL_MS;
-    this.cacheKeypair(keypair, ttl);
-  }
-  /**
-   * Get time remaining until cache expires (in milliseconds)
-   * Returns 0 if not cached
-   */
-  getCacheTimeRemaining() {
-    if (!this.isCached() || !this.cacheExpiry) {
-      return 0;
-    }
-    const remaining = this.cacheExpiry - Date.now();
-    return Math.max(0, remaining);
-  }
-  /**
-   * Extend cache expiry time
-   * Useful to keep session active during user activity
-   * 
-   * @example
-   * ```typescript
-   * // Extend cache by 15 minutes on each payment
-   * await sessionKey.signTransaction(tx, '');
-   * sessionKey.extendCache(15 * 60 * 1000);
-   * ```
-   */
-  extendCache(additionalTTL) {
-    if (!this.isCached()) {
-      throw new Error("Cannot extend cache: no cached keypair");
-    }
-    this.cacheExpiry += additionalTTL;
-  }
-  /**
-   * Set session key ID after backend creation
-   */
-  setSessionKeyId(id) {
-    this.sessionKeyId = id;
-  }
-  /**
-   * Get session key ID
-   */
-  getSessionKeyId() {
-    if (!this.sessionKeyId) {
-      throw new Error("Session key not registered with backend");
-    }
-    return this.sessionKeyId;
-  }
-};
-async function encryptKeypairWithLit(keypair, options) {
-  const network = options?.network || "datil";
-  const debug = options?.debug || false;
-  if (debug) {
-    console.log("[Lit] Encrypting keypair with Lit Protocol...");
-  }
-  try {
-    const { LitNodeClient } = await import("@lit-protocol/lit-node-client");
-    const litClient = new LitNodeClient({
-      litNetwork: network,
-      debug
-    });
-    await litClient.connect();
-    if (debug) {
-      console.log(`[Lit] Connected to ${network}`);
-    }
-    try {
-      const evmContractConditions = [
-        {
-          contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-          // USDC on Ethereum
-          functionName: "balanceOf",
-          functionParams: [":userAddress"],
-          functionAbi: {
-            constant: true,
-            inputs: [{ name: "account", type: "address" }],
-            name: "balanceOf",
-            outputs: [{ name: "", type: "uint256" }],
-            stateMutability: "view",
-            type: "function"
-          },
-          chain: "ethereum",
-          returnValueTest: {
-            key: "",
-            comparator: ">=",
-            value: "0"
-          }
-        }
-      ];
-      const dataToEncrypt = keypair.secretKey;
-      if (debug) {
-        console.log("[Lit] Encrypting keypair bytes with evmContractConditions...");
-      }
-      const encryptResult = await litClient.encrypt({
-        evmContractConditions,
-        dataToEncrypt
-      });
-      if (debug) {
-        console.log("[Lit] \u2705 Encryption successful");
-      }
-      return {
-        ciphertext: encryptResult.ciphertext,
-        dataHash: encryptResult.dataToEncryptHash
-      };
-    } finally {
-      await litClient.disconnect();
-    }
-  } catch (error) {
-    if (debug) {
-      console.error("[Lit] \u274C Encryption failed:", error);
-    }
-    throw new Error(
-      `Lit Protocol encryption failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-
-// src/aip/session-keys.ts
-var import_web32 = require("@solana/web3.js");
-var SessionKeysAPI = class {
-  sessionKeys = /* @__PURE__ */ new Map();
-  sessionMetadata = /* @__PURE__ */ new Map();
-  requestFn;
-  debugMode = false;
-  constructor(request) {
-    this.requestFn = request;
-  }
-  /**
-   * Enable debug logging
-   */
-  debug(...args) {
-    if (this.debugMode && typeof console !== "undefined") {
-      console.log("[ZendFi SessionKeys]", ...args);
-    }
-  }
-  /**
-   * Create a new device-bound session key
-   *
-   * The keypair is generated client-side and encrypted with your PIN.
-   * The backend NEVER sees your private key.
-   *
-   * @param options - Session key configuration
-   * @returns Created session key info with optional recovery QR
-   *
-   * @example
-   * ```typescript
-   * const result = await zendfi.sessionKeys.create({
-   *   userWallet: '7xKNH...',
-   *   agentId: 'shopping-assistant-v1',
-   *   agentName: 'AI Shopping Assistant',
-   *   limitUSDC: 100,
-   *   durationDays: 7,
-   *   pin: '123456',
-   *   generateRecoveryQR: true,
-   * });
-   *
-   * console.log(`Session key: ${result.sessionKeyId}`);
-   * console.log(`Recovery QR: ${result.recoveryQR}`);
-   * ```
-   */
-  async create(options) {
-    if (!options.pin || options.pin.length < 4) {
-      throw new Error("PIN must be at least 4 characters");
-    }
-    const sessionKey = await DeviceBoundSessionKey.create({
-      pin: options.pin,
-      limitUSDC: options.limitUSDC,
-      durationDays: options.durationDays,
-      userWallet: options.userWallet,
-      generateRecoveryQR: options.generateRecoveryQR
-    });
-    const encrypted = sessionKey.getEncryptedData();
-    let recoveryQR;
-    if (options.generateRecoveryQR) {
-      const qr = RecoveryQRGenerator.generate(encrypted);
-      recoveryQR = RecoveryQRGenerator.encode(qr);
-    }
-    let litEncryption;
-    const enableLit = options.enableLitProtocol !== false;
-    if (enableLit) {
-      const maxRetries = 3;
-      let lastError;
-      for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        try {
-          this.debug(`Encrypting session key with Lit Protocol (attempt ${attempt}/${maxRetries})...`);
-          litEncryption = await encryptKeypairWithLit(sessionKey.getKeypair(), {
-            network: options.litNetwork || "datil",
-            debug: this.debugMode
-          });
-          this.debug("Lit Protocol encryption successful - autonomous signing enabled");
-          break;
-        } catch (error) {
-          lastError = error instanceof Error ? error : new Error(String(error));
-          if (attempt < maxRetries) {
-            const delayMs = 500 * Math.pow(2, attempt - 1);
-            this.debug(`Lit encryption attempt ${attempt} failed, retrying in ${delayMs}ms...`);
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-          } else {
-            const errorMsg = lastError.message;
-            this.debug("Lit encryption failed after 3 attempts, continuing without autonomous mode:", errorMsg);
-            console.warn("[ZendFi SDK] Lit Protocol encryption failed after retries:", errorMsg);
-          }
-        }
-      }
-    } else {
-      this.debug("\u2139\uFE0F  Lit Protocol disabled - autonomous signing not available");
-    }
-    const request = {
-      user_wallet: options.userWallet,
-      agent_id: options.agentId,
-      agent_name: options.agentName,
-      limit_usdc: options.limitUSDC,
-      duration_days: options.durationDays,
-      encrypted_session_key: encrypted.encryptedData,
-      nonce: encrypted.nonce,
-      session_public_key: encrypted.publicKey,
-      device_fingerprint: sessionKey.getDeviceFingerprint(),
-      recovery_qr_data: recoveryQR,
-      // Include Lit encryption if available
-      lit_encrypted_keypair: litEncryption?.ciphertext,
-      lit_data_hash: litEncryption?.dataHash
-    };
-    const response = await this.requestFn(
-      "POST",
-      "/api/v1/ai/session-keys/device-bound/create",
-      request
-    );
-    sessionKey.setSessionKeyId(response.session_key_id);
-    this.sessionKeys.set(response.session_key_id, sessionKey);
-    this.sessionMetadata.set(response.session_key_id, {
-      agentId: response.agent_id,
-      agentName: response.agent_name
-    });
-    return {
-      sessionKeyId: response.session_key_id,
-      agentId: response.agent_id,
-      agentName: response.agent_name,
-      sessionWallet: response.session_wallet,
-      limitUsdc: response.limit_usdc,
-      expiresAt: response.expires_at,
-      recoveryQR,
-      crossAppCompatible: response.cross_app_compatible
-    };
-  }
-  /**
-   * Load an existing session key from backend
-   *
-   * Fetches the encrypted session key and decrypts it with your PIN.
-   * Use this when resuming a session on the same device.
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @param pin - PIN to decrypt the session key
-   *
-   * @example
-   * ```typescript
-   * // Resume session on same device
-   * await zendfi.sessionKeys.load('uuid-of-session-key', '123456');
-   *
-   * // Now you can make payments
-   * await zendfi.sessionKeys.makePayment({...});
-   * ```
-   */
-  async load(sessionKeyId, pin) {
-    const deviceInfo = await DeviceFingerprintGenerator.generate();
-    const response = await this.requestFn(
-      "POST",
-      "/api/v1/ai/session-keys/device-bound/get-encrypted",
-      {
-        session_key_id: sessionKeyId,
-        device_fingerprint: deviceInfo.fingerprint
-      }
-    );
-    if (!response.device_fingerprint_valid) {
-      throw new Error(
-        "Device fingerprint mismatch - this session key was created on a different device. Use recover() to migrate."
-      );
-    }
-    const encrypted = {
-      encryptedData: response.encrypted_session_key,
-      nonce: response.nonce,
-      publicKey: "",
-      // Will be populated after decryption
-      deviceFingerprint: deviceInfo.fingerprint,
-      version: "argon2id-aes256gcm-v1"
-    };
-    const keypair = await SessionKeyCrypto.decrypt(encrypted, pin, deviceInfo.fingerprint);
-    encrypted.publicKey = keypair.publicKey.toBase58();
-    const sessionKey = new DeviceBoundSessionKey();
-    sessionKey.encrypted = encrypted;
-    sessionKey.deviceFingerprint = deviceInfo;
-    sessionKey.setSessionKeyId(sessionKeyId);
-    this.sessionKeys.set(sessionKeyId, sessionKey);
-  }
-  /**
-   * Unlock a session key for auto-signing
-   *
-   * After unlocking, payments can be made without entering PIN.
-   * The decrypted keypair is cached in memory with a TTL.
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @param pin - PIN to decrypt the session key
-   * @param cacheTTL - How long to cache (default: 30 minutes)
-   *
-   * @example
-   * ```typescript
-   * // Unlock once
-   * await zendfi.sessionKeys.unlock('uuid', '123456');
-   *
-   * // Make payments instantly (no PIN!)
-   * await zendfi.sessionKeys.makePayment({...}); // Instant!
-   * await zendfi.sessionKeys.makePayment({...}); // Instant!
-   * ```
-   */
-  async unlock(sessionKeyId, pin, cacheTTL) {
-    const sessionKey = this.sessionKeys.get(sessionKeyId);
-    if (!sessionKey) {
-      await this.load(sessionKeyId, pin);
-      const loaded = this.sessionKeys.get(sessionKeyId);
-      if (loaded) {
-        await loaded.unlockWithPin(pin, cacheTTL);
-      }
-      return;
-    }
-    await sessionKey.unlockWithPin(pin, cacheTTL);
-  }
-  /**
-   * Make a payment using a session key
-   *
-   * If the session key is unlocked (cached), no PIN is needed.
-   * Otherwise, you must provide the PIN.
-   *
-   * @param options - Payment configuration
-   * @returns Payment result with signature
-   *
-   * @example
-   * ```typescript
-   * // With unlocked session key (no PIN)
-   * const result = await zendfi.sessionKeys.makePayment({
-   *   sessionKeyId: 'uuid',
-   *   amount: 5.0,
-   *   recipient: '8xYZA...',
-   *   description: 'Coffee purchase',
-   * });
-   *
-   * // Or with PIN (one-time)
-   * const result = await zendfi.sessionKeys.makePayment({
-   *   sessionKeyId: 'uuid',
-   *   amount: 5.0,
-   *   recipient: '8xYZA...',
-   *   pin: '123456',
-   * });
-   * ```
-   */
-  async makePayment(options) {
-    const sessionKey = this.sessionKeys.get(options.sessionKeyId);
-    if (!sessionKey) {
-      throw new Error(
-        `Session key ${options.sessionKeyId} not loaded. Call create() or load() first.`
-      );
-    }
-    const enableAutoSign = options.enableAutoSign !== false;
-    const needsPin = !sessionKey.isCached();
-    if (needsPin && !options.pin) {
-      throw new Error(
-        "PIN required: session key not unlocked. Provide PIN or call unlock() first."
-      );
-    }
-    const metadata = this.sessionMetadata.get(options.sessionKeyId);
-    if (!metadata) {
-      throw new Error(
-        `Session key metadata not found for ${options.sessionKeyId}. Was it created in this session?`
-      );
-    }
-    const paymentResponse = await this.requestFn("POST", "/api/v1/ai/smart-payment", {
-      agent_id: metadata.agentId,
-      // Required by backend
-      amount_usd: options.amount,
-      user_wallet: sessionKey.getPublicKey(),
-      // Session key's wallet (payer)
-      token: options.token || "USDC",
-      description: options.description,
-      session_key_id: options.sessionKeyId
-    });
-    if (!paymentResponse.requires_signature && paymentResponse.status === "confirmed") {
-      return {
-        paymentId: paymentResponse.payment_id,
-        signature: "",
-        status: paymentResponse.status
-      };
-    }
-    if (!paymentResponse.unsigned_transaction) {
-      throw new Error("Backend did not return unsigned transaction");
-    }
-    const transactionBuffer = Buffer.from(paymentResponse.unsigned_transaction, "base64");
-    const transaction = import_web32.Transaction.from(transactionBuffer);
-    const signedTransaction = await sessionKey.signTransaction(
-      transaction,
-      options.pin || "",
-      enableAutoSign
-    );
-    const submitResponse = await this.requestFn("POST", `/api/v1/ai/payments/${paymentResponse.payment_id}/submit-signed`, {
-      signed_transaction: signedTransaction.serialize().toString("base64")
-    });
-    return {
-      paymentId: paymentResponse.payment_id,
-      signature: submitResponse.signature,
-      status: submitResponse.status
-    };
-  }
-  /**
-   * Get session key status
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @returns Current status including balance and expiry
-   */
-  async getStatus(sessionKeyId) {
-    const response = await this.requestFn("POST", "/api/v1/ai/session-keys/status", {
-      session_key_id: sessionKeyId
-    });
-    return {
-      sessionKeyId,
-      isActive: response.is_active,
-      isApproved: response.is_approved,
-      limitUsdc: response.limit_usdc,
-      usedAmountUsdc: response.used_amount_usdc,
-      remainingUsdc: response.remaining_usdc,
-      expiresAt: response.expires_at,
-      daysUntilExpiry: response.days_until_expiry
-    };
-  }
-  /**
-   * Revoke a session key
-   *
-   * Permanently deactivates the session key. Cannot be undone.
-   *
-   * @param sessionKeyId - UUID of the session key to revoke
-   */
-  async revoke(sessionKeyId) {
-    await this.requestFn("POST", "/api/v1/ai/session-keys/revoke", {
-      session_key_id: sessionKeyId
-    });
-    this.sessionKeys.delete(sessionKeyId);
-  }
-  /**
-   * Recover session key on new device
-   *
-   * Use this when moving to a new device with a recovery QR code.
-   *
-   * @param options - Recovery configuration
-   *
-   * @example
-   * ```typescript
-   * await zendfi.sessionKeys.recover({
-   *   sessionKeyId: 'uuid',
-   *   recoveryQR: '{"encryptedSessionKey":"..."}',
-   *   oldPin: '123456',
-   *   newPin: '654321',
-   * });
-   * ```
-   */
-  async recover(options) {
-    const recoveryData = RecoveryQRGenerator.decode(options.recoveryQR);
-    const newDeviceInfo = await DeviceFingerprintGenerator.generate();
-    const newEncrypted = await RecoveryQRGenerator.reEncryptForNewDevice(
-      recoveryData,
-      options.oldPin,
-      "recovery-mode",
-      // Old fingerprint (stored in QR in production)
-      options.newPin,
-      newDeviceInfo.fingerprint
-    );
-    await this.requestFn(
-      "POST",
-      `/api/v1/ai/session-keys/device-bound/${options.sessionKeyId}/recover`,
-      {
-        recovery_qr_data: options.recoveryQR,
-        new_device_fingerprint: newDeviceInfo.fingerprint,
-        new_encrypted_session_key: newEncrypted.encryptedData,
-        new_nonce: newEncrypted.nonce
-      }
-    );
-    await this.load(options.sessionKeyId, options.newPin);
-  }
-  /**
-   * Clear cached keypair for a session key
-   *
-   * Use this on logout or when session ends.
-   *
-   * @param sessionKeyId - UUID of the session key (or all if not specified)
-   */
-  clearCache(sessionKeyId) {
-    if (sessionKeyId) {
-      const sessionKey = this.sessionKeys.get(sessionKeyId);
-      if (sessionKey) {
-        sessionKey.clearCache();
-      }
-    } else {
-      for (const sessionKey of this.sessionKeys.values()) {
-        sessionKey.clearCache();
-      }
-    }
-  }
-  /**
-   * Check if a session key is cached (unlocked)
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @returns True if keypair is cached and auto-signing is enabled
-   */
-  isCached(sessionKeyId) {
-    const sessionKey = this.sessionKeys.get(sessionKeyId);
-    return sessionKey?.isCached() || false;
-  }
-  /**
-   * Get time remaining until cache expires
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @returns Milliseconds until cache expires
-   */
-  getCacheTimeRemaining(sessionKeyId) {
-    const sessionKey = this.sessionKeys.get(sessionKeyId);
-    return sessionKey?.getCacheTimeRemaining() || 0;
-  }
-  /**
-   * Extend cache expiry time
-   *
-   * Useful to keep session active during user activity.
-   *
-   * @param sessionKeyId - UUID of the session key
-   * @param additionalTTL - Additional time in milliseconds
-   */
-  extendCache(sessionKeyId, additionalTTL) {
-    const sessionKey = this.sessionKeys.get(sessionKeyId);
-    if (sessionKey) {
-      sessionKey.extendCache(additionalTTL);
-    }
-  }
-  /**
-   * Get all loaded session key IDs
-   *
-   * @returns Array of session key UUIDs currently loaded
-   */
-  getLoadedSessionKeys() {
-    return Array.from(this.sessionKeys.keys());
-  }
-};
-
-// src/client.ts
-var ZendFiClient = class {
-  config;
-  interceptors;
-  // ============================================
-  // Agentic Intent Protocol APIs
-  // ============================================
-  /**
-   * Agent API - Manage agent API keys and sessions
-   * 
-   * @example
-   * ```typescript
-   * // Create an agent API key
-   * const agentKey = await zendfi.agent.createKey({
-   *   name: 'Shopping Assistant',
-   *   agent_id: 'shopping-assistant-v1',
-   *   scopes: ['create_payments'],
-   * });
-   * 
-   * // Create an agent session
-   * const session = await zendfi.agent.createSession({
-   *   agent_id: 'shopping-assistant-v1',
-   *   user_wallet: 'Hx7B...abc',
-   *   limits: { max_per_day: 500 },
-   * });
-   * ```
-   */
-  agent;
-  /**
-   * Payment Intents API - Two-phase payment flow
-   * 
-   * @example
-   * ```typescript
-   * // Create intent
-   * const intent = await zendfi.intents.create({ amount: 99.99 });
-   * 
-   * // Confirm when ready
-   * await zendfi.intents.confirm(intent.id, {
-   *   client_secret: intent.client_secret,
-   *   customer_wallet: 'Hx7B...abc',
-   * });
-   * ```
-   */
-  intents;
-  /**
-   * Pricing API - PPP and AI-powered pricing
-   * 
-   * @example
-   * ```typescript
-   * // Get PPP factor for Brazil
-   * const factor = await zendfi.pricing.getPPPFactor('BR');
-   * const localPrice = 100 * factor.ppp_factor; // $35 for Brazil
-   * 
-   * // Get AI pricing suggestion
-   * const suggestion = await zendfi.pricing.getSuggestion({
-   *   agent_id: 'my-agent',
-   *   base_price: 100,
-   *   user_profile: { location_country: 'BR' },
-   * });
-   * ```
-   */
-  pricing;
-  /**
-   * Autonomy API - Enable autonomous agent signing
-   * 
-   * @example
-   * ```typescript
-   * // Enable autonomous mode for a session key
-   * const delegate = await zendfi.autonomy.enable(sessionKeyId, {
-   *   max_amount_usd: 100,
-   *   duration_hours: 24,
-   *   delegation_signature: signature,
-   * });
-   * 
-   * // Check status
-   * const status = await zendfi.autonomy.getStatus(sessionKeyId);
-   * ```
-   */
-  autonomy;
-  /**
-   * Smart Payments API - AI-powered payment routing
-   * 
-   * Create intelligent payments that automatically:
-   * - Apply PPP discounts based on user location
-   * - Use agent sessions when available
-   * - Route to optimal payment paths
-   * 
-   * @example
-   * ```typescript
-   * const payment = await zendfi.smart.create({
-   *   amount_usd: 99.99,
-   *   wallet_address: 'Hx7B...abc',
-   *   merchant_id: 'merch_123',
-   *   country_code: 'BR', // Apply PPP
-   *   enable_ppp: true,
-   * });
-   * 
-   * console.log(`Original: $${payment.original_amount_usd}`);
-   * console.log(`Final: $${payment.final_amount_usd}`);
-   * // Original: $99.99
-   * // Final: $64.99 (35% PPP discount applied)
-   * ```
-   */
-  smart;
-  /**
-   * Session Keys API - On-chain funded session keys with PKP identity
-   * 
-   * Session keys are pre-funded wallets with spending limits that enable
-   * AI agents to make autonomous payments without user signatures.
-   * 
-   * The flow:
-   * 1. Create a session key (user approves spending limit)
-   * 2. User signs the approval transaction (one-time)
-   * 3. Agent can now make payments up to the limit
-   * 
-   * @example
-   * ```typescript
-   * // Create session key
-   * const key = await zendfi.sessionKeys.create({
-   *   agent_id: 'shopping-bot',
-   *   user_wallet: 'Hx7B...abc',
-   *   max_amount: 100,
-   *   expiry_hours: 24,
-   * });
-   * 
-   * // User signs the approval
-   * await zendfi.sessionKeys.submitApproval(key.session_key_id, {
-   *   signed_transaction: signedTx,
-   * });
-   * 
-   * // Check status
-   * const status = await zendfi.sessionKeys.getStatus(key.session_key_id);
-   * console.log(`Remaining: $${status.remaining_amount}`);
-   * ```
-   */
-  sessionKeys;
-  constructor(options) {
-    this.config = ConfigLoader.load(options);
-    ConfigLoader.validateApiKey(this.config.apiKey);
-    this.interceptors = createInterceptors();
-    const boundRequest = this.request.bind(this);
-    this.agent = new AgentAPI(boundRequest);
-    this.intents = new PaymentIntentsAPI(boundRequest);
-    this.pricing = new PricingAPI(boundRequest);
-    this.autonomy = new AutonomyAPI(boundRequest);
-    this.smart = new SmartPaymentsAPI(boundRequest);
-    this.sessionKeys = new SessionKeysAPI(boundRequest);
-    if (this.config.environment === "development" || this.config.debug) {
-      console.log(
-        `\u2713 ZendFi SDK initialized in ${this.config.mode} mode (${this.config.mode === "test" ? "devnet" : "mainnet"})`
-      );
-      if (this.config.debug) {
-        console.log("[ZendFi] Debug mode enabled");
-      }
-    }
-  }
-  /**
-   * Create a new payment
-   */
-  async createPayment(request) {
-    return this.request("POST", "/api/v1/payments", {
-      ...request,
-      currency: request.currency || "USD",
-      token: request.token || "USDC"
-    });
-  }
-  /**
-   * Get payment by ID
-   */
-  async getPayment(paymentId) {
-    return this.request("GET", `/api/v1/payments/${paymentId}`);
-  }
-  /**
-   * List all payments with pagination
-   */
-  async listPayments(request) {
-    const params = new URLSearchParams();
-    if (request?.page) params.append("page", request.page.toString());
-    if (request?.limit) params.append("limit", request.limit.toString());
-    if (request?.status) params.append("status", request.status);
-    if (request?.from_date) params.append("from_date", request.from_date);
-    if (request?.to_date) params.append("to_date", request.to_date);
-    const query = params.toString() ? `?${params.toString()}` : "";
-    return this.request("GET", `/api/v1/payments${query}`);
-  }
-  /**
-   * Create a subscription plan
-   */
-  async createSubscriptionPlan(request) {
-    return this.request("POST", "/api/v1/subscriptions/plans", {
-      ...request,
-      currency: request.currency || "USD",
-      interval_count: request.interval_count || 1,
-      trial_days: request.trial_days || 0
-    });
-  }
-  /**
-   * Get subscription plan by ID
-   */
-  async getSubscriptionPlan(planId) {
-    return this.request("GET", `/api/v1/subscriptions/plans/${planId}`);
-  }
-  /**
-   * Create a subscription
-   */
-  async createSubscription(request) {
-    return this.request("POST", "/api/v1/subscriptions", request);
-  }
-  /**
-   * Get subscription by ID
-   */
-  async getSubscription(subscriptionId) {
-    return this.request("GET", `/api/v1/subscriptions/${subscriptionId}`);
-  }
-  /**
-   * Cancel a subscription
-   */
-  async cancelSubscription(subscriptionId) {
-    return this.request(
-      "POST",
-      `/api/v1/subscriptions/${subscriptionId}/cancel`
-    );
-  }
-  /**
-   * Create a payment link (shareable checkout URL)
-   */
-  async createPaymentLink(request) {
-    const response = await this.request("POST", "/api/v1/payment-links", {
-      ...request,
-      currency: request.currency || "USD",
-      token: request.token || "USDC",
-      onramp: request.onramp || false
-    });
-    return {
-      ...response,
-      url: response.hosted_page_url
-    };
-  }
-  /**
-   * Get payment link by link code
-   */
-  async getPaymentLink(linkCode) {
-    const response = await this.request("GET", `/api/v1/payment-links/${linkCode}`);
-    return {
-      ...response,
-      url: response.hosted_page_url
-    };
-  }
-  /**
-   * List all payment links for the authenticated merchant
-   */
-  async listPaymentLinks() {
-    const response = await this.request("GET", "/api/v1/payment-links");
-    return response.map((link) => ({
-      ...link,
-      url: link.hosted_page_url
-    }));
-  }
-  /**
-   * Create an installment plan
-   * Split a purchase into multiple scheduled payments
-   */
-  async createInstallmentPlan(request) {
-    const response = await this.request(
-      "POST",
-      "/api/v1/installment-plans",
-      request
-    );
-    return {
-      id: response.plan_id,
-      plan_id: response.plan_id,
-      status: response.status
-    };
-  }
-  /**
-   * Get installment plan by ID
-   */
-  async getInstallmentPlan(planId) {
-    return this.request("GET", `/api/v1/installment-plans/${planId}`);
+  async getInstallmentPlan(planId) {
+    return this.request("GET", `/api/v1/installment-plans/${planId}`);
   }
   /**
    * List all installment plans for merchant
@@ -3203,63 +667,14 @@ var ZendFiClient = class {
     );
   }
   /**
-   * Cancel an installment plan
-   */
-  async cancelInstallmentPlan(planId) {
-    return this.request(
-      "POST",
-      `/api/v1/installment-plans/${planId}/cancel`
-    );
-  }
-  /**
-   * Create an escrow transaction
-   * Hold funds until conditions are met
-   */
-  async createEscrow(request) {
-    return this.request("POST", "/api/v1/escrows", {
-      ...request,
-      currency: request.currency || "USD",
-      token: request.token || "USDC"
-    });
-  }
-  /**
-   * Get escrow by ID
-   */
-  async getEscrow(escrowId) {
-    return this.request("GET", `/api/v1/escrows/${escrowId}`);
-  }
-  /**
-   * List all escrows for merchant
-   */
-  async listEscrows(params) {
-    const query = new URLSearchParams();
-    if (params?.limit) query.append("limit", params.limit.toString());
-    if (params?.offset) query.append("offset", params.offset.toString());
-    const queryString = query.toString() ? `?${query.toString()}` : "";
-    return this.request("GET", `/api/v1/escrows${queryString}`);
-  }
-  /**
-   * Approve escrow release to seller
+   * Cancel an installment plan
    */
-  async approveEscrow(escrowId, request) {
+  async cancelInstallmentPlan(planId) {
     return this.request(
       "POST",
-      `/api/v1/escrows/${escrowId}/approve`,
-      request
+      `/api/v1/installment-plans/${planId}/cancel`
     );
   }
-  /**
-   * Refund escrow to buyer
-   */
-  async refundEscrow(escrowId, request) {
-    return this.request("POST", `/api/v1/escrows/${escrowId}/refund`, request);
-  }
-  /**
-   * Raise a dispute for an escrow
-   */
-  async disputeEscrow(escrowId, request) {
-    return this.request("POST", `/api/v1/escrows/${escrowId}/dispute`, request);
-  }
   /**
    * Create an invoice
    */
@@ -3287,54 +702,6 @@ var ZendFiClient = class {
   async sendInvoice(invoiceId) {
     return this.request("POST", `/api/v1/invoices/${invoiceId}/send`);
   }
-  // ============================================
-  // Agentic Intent Protocol - Smart Payments
-  // ============================================
-  /**
-   * Execute an AI-powered smart payment
-   * 
-   * Smart payments combine multiple features:
-   * - Automatic PPP pricing adjustments
-   * - Gasless transaction detection
-   * - Instant settlement options
-   * - Escrow integration
-   * - Receipt generation
-   * 
-   * @param request - Smart payment configuration
-   * @returns Payment result with status and receipt
-   * 
-   * @example
-   * ```typescript
-   * const result = await zendfi.smartPayment({
-   *   agent_id: 'shopping-assistant',
-   *   user_wallet: 'Hx7B...abc',
-   *   amount_usd: 50,
-   *   auto_detect_gasless: true,
-   *   description: 'Premium subscription',
-   * });
-   * 
-   * if (result.requires_signature) {
-   *   // Device-bound flow: user needs to sign
-   *   console.log('Sign and submit:', result.submit_url);
-   * } else {
-   *   // Auto-signed
-   *   console.log('Payment complete:', result.transaction_signature);
-   * }
-   * ```
-   */
-  async smartPayment(request) {
-    return this.smart.execute(request);
-  }
-  /**
-   * Submit a signed transaction for device-bound smart payment
-   * 
-   * @param paymentId - UUID of the payment
-   * @param signedTransaction - Base64 encoded signed transaction
-   * @returns Updated payment response
-   */
-  async submitSignedPayment(paymentId, signedTransaction) {
-    return this.smart.submitSigned(paymentId, signedTransaction);
-  }
   /**
    * Verify webhook signature using HMAC-SHA256
    * 
@@ -3628,6 +995,8 @@ var ZendFiEmbeddedCheckout = class {
   mounted = false;
   paymentProcessed = false;
   // Prevent duplicate success callbacks
+  // Bank payment state
+  bankPaymentState = {};
   constructor(config) {
     this.config = {
       linkCode: config.linkCode || "",
@@ -3646,7 +1015,8 @@ var ZendFiEmbeddedCheckout = class {
       paymentMethods: config.paymentMethods || {
         walletConnect: true,
         qrCode: true,
-        solanaWallet: true
+        solanaWallet: true,
+        bank: true
       }
     };
     if (!this.config.linkCode && !this.config.paymentId) {
@@ -3909,12 +1279,14 @@ var ZendFiEmbeddedCheckout = class {
    */
   renderPaymentMethods() {
     if (!this.checkoutData) return "";
+    const showBank = this.config.paymentMethods.bank && this.checkoutData.onramp;
     return `
       <div class="zendfi-payment-methods" style="padding: 24px;">
         <h3 style="margin: 0 0 16px 0; font-size: 16px; font-weight: 600; color: #1f2937;">
           Payment Methods
         </h3>
         
+        ${showBank ? this.renderBankMethod() : ""}
         ${this.config.paymentMethods.qrCode ? this.renderQRCodeMethod() : ""}
         ${this.config.paymentMethods.solanaWallet ? this.renderWalletMethod() : ""}
         ${this.config.paymentMethods.walletConnect ? this.renderWalletConnectMethod() : ""}
@@ -3981,6 +1353,142 @@ var ZendFiEmbeddedCheckout = class {
       </div>
     `;
   }
+  /**
+   * Render bank payment method (PAJ Ramp onramp)
+   */
+  renderBankMethod() {
+    if (!this.checkoutData) return "";
+    const isEmailStep = !this.bankPaymentState.orderId;
+    const isBankDetailsStep = !!this.bankPaymentState.bankDetails;
+    return `
+      <div class="zendfi-payment-method" style="padding: 16px; border: 2px solid #10b981; border-radius: 12px; margin-bottom: 16px; background: #f0fdf4;">
+        <div style="margin-bottom: 12px;">
+          <h4 style="margin: 0 0 4px 0; font-size: 16px; font-weight: 600; color: #065f46; display: flex; align-items: center;">
+            \u{1F3E6} Pay with Bank Transfer (Nigeria)
+          </h4>
+          <p style="margin: 0; font-size: 12px; color: #047857;">
+            Pay with your Nigerian bank account \u2022 Instant confirmation
+          </p>
+        </div>
+        
+        ${isEmailStep ? this.renderBankEmailStep() : ""}
+        ${isBankDetailsStep ? this.renderBankDetailsStep() : ""}
+      </div>
+    `;
+  }
+  /**
+   * Render bank email/OTP step
+   */
+  renderBankEmailStep() {
+    return `
+      <div id="zendfi-bank-email-step">
+        <div style="margin-bottom: 12px;">
+          <label style="display: block; font-size: 14px; color: #374151; margin-bottom: 4px; font-weight: 500;">
+            Email Address
+          </label>
+          <input
+            type="email"
+            id="zendfi-bank-email"
+            placeholder="your@email.com"
+            style="width: 100%; padding: 10px; border: 1px solid #d1d5db; border-radius: 8px; font-size: 14px;"
+          />
+        </div>
+        
+        <div id="zendfi-bank-otp-container" style="display: none; margin-bottom: 12px;">
+          <label style="display: block; font-size: 14px; color: #374151; margin-bottom: 4px; font-weight: 500;">
+            Verification Code
+          </label>
+          <input
+            type="text"
+            id="zendfi-bank-otp"
+            placeholder="Enter 4-digit code"
+            maxlength="4"
+            style="width: 100%; padding: 10px; border: 1px solid #d1d5db; border-radius: 8px; font-size: 14px;"
+          />
+          <p style="font-size: 12px; color: #6b7280; margin-top: 4px;">
+            Check your email for the verification code
+          </p>
+        </div>
+        
+        <button
+          id="zendfi-bank-submit"
+          style="width: 100%; padding: 12px; background: #10b981; color: white; border: none; border-radius: 8px; font-size: 14px; font-weight: 600; cursor: pointer; transition: all 0.2s;"
+          onmouseover="this.style.background='#059669';"
+          onmouseout="this.style.background='#10b981';"
+        >
+          Send Verification Code
+        </button>
+        
+        <div id="zendfi-bank-error" style="display: none; margin-top: 12px; padding: 12px; background: #fee2e2; border: 1px solid #fecaca; border-radius: 8px; color: #991b1b; font-size: 14px;"></div>
+      </div>
+    `;
+  }
+  /**
+   * Render bank details step
+   */
+  renderBankDetailsStep() {
+    if (!this.bankPaymentState.bankDetails) return "";
+    const { accountNumber, accountName, bankName, amount } = this.bankPaymentState.bankDetails;
+    return `
+      <div id="zendfi-bank-details-step">
+        <div style="background: white; border: 1px solid #d1d5db; border-radius: 8px; padding: 16px; margin-bottom: 16px;">
+          <h5 style="margin: 0 0 12px 0; font-size: 14px; font-weight: 600; color: #374151;">
+            \u{1F4CB} Transfer to this account:
+          </h5>
+          
+          <div style="margin-bottom: 8px;">
+            <div style="font-size: 12px; color: #6b7280; margin-bottom: 2px;">Bank Name</div>
+            <div style="font-weight: 600; color: #111827;">${bankName}</div>
+          </div>
+          
+          <div style="margin-bottom: 8px;">
+            <div style="font-size: 12px; color: #6b7280; margin-bottom: 2px;">Account Number</div>
+            <div style="font-weight: 600; color: #111827; font-size: 18px; display: flex; align-items: center; gap: 8px;">
+              <span id="zendfi-bank-account">${accountNumber}</span>
+              <button
+                id="zendfi-copy-account"
+                style="padding: 2px 6px; font-size: 11px; background: #f3f4f6; border: 1px solid #d1d5db; border-radius: 4px; cursor: pointer;"
+              >
+                Copy
+              </button>
+            </div>
+          </div>
+          
+          <div style="margin-bottom: 8px;">
+            <div style="font-size: 12px; color: #6b7280; margin-bottom: 2px;">Account Name</div>
+            <div style="font-weight: 600; color: #111827;">${accountName}</div>
+          </div>
+          
+          <div style="margin-top: 12px; padding-top: 12px; border-top: 1px solid #e5e7eb;">
+            <div style="font-size: 12px; color: #6b7280; margin-bottom: 2px;">Amount to Send</div>
+            <div style="font-size: 24px; font-weight: 700; color: #8866ff;">${amount.toFixed(2)} NGN</div>
+          </div>
+        </div>
+        
+        <div style="background: #fef3c7; border: 1px solid #fcd34d; border-radius: 8px; padding: 12px; margin-bottom: 16px;">
+          <p style="margin: 0; font-size: 12px; color: #92400e;">
+            <strong>Important:</strong> Transfer the exact amount shown above. Payment will auto-complete in 10-30 seconds.
+          </p>
+        </div>
+        
+        <div id="zendfi-bank-status" style="text-align: center; padding: 16px;">
+          <div class="zendfi-spinner" style="margin: 0 auto 8px;"></div>
+          <div style="color: #6b7280; font-size: 14px;" id="zendfi-bank-status-text">
+            Waiting for bank transfer... (<span id="zendfi-bank-timer">0:00</span>)
+          </div>
+          <div style="font-size: 12px; color: #9ca3af; margin-top: 4px;">
+            \u23F1\uFE0F Usually takes 10-30 seconds
+          </div>
+          <button
+            id="zendfi-refresh-status"
+            style="margin-top: 12px; padding: 8px 16px; background: white; border: 1px solid #e5e7eb; border-radius: 8px; cursor: pointer; color: #6b7280; font-size: 14px;"
+          >
+            \u{1F504} Refresh Status
+          </button>
+        </div>
+      </div>
+    `;
+  }
   /**
    * Render footer
    */
@@ -4053,6 +1561,29 @@ var ZendFiEmbeddedCheckout = class {
     if (walletConnectBtn) {
       walletConnectBtn.addEventListener("click", () => this.handleWalletConnectScan());
     }
+    const bankSubmitBtn = document.getElementById("zendfi-bank-submit");
+    if (bankSubmitBtn) {
+      bankSubmitBtn.addEventListener("click", () => this.handleBankSubmit());
+    }
+    const copyAccountBtn = document.getElementById("zendfi-copy-account");
+    if (copyAccountBtn) {
+      copyAccountBtn.addEventListener("click", () => {
+        const accountNum = document.getElementById("zendfi-bank-account")?.textContent || "";
+        navigator.clipboard.writeText(accountNum);
+        copyAccountBtn.textContent = "Copied!";
+        copyAccountBtn.style.background = "#15803D";
+        copyAccountBtn.style.color = "white";
+        setTimeout(() => {
+          copyAccountBtn.textContent = "Copy";
+          copyAccountBtn.style.background = "";
+          copyAccountBtn.style.color = "";
+        }, 2e3);
+      });
+    }
+    const refreshBtn = document.getElementById("zendfi-refresh-status");
+    if (refreshBtn) {
+      refreshBtn.addEventListener("click", () => this.refreshBankStatus());
+    }
   }
   /**
    * Handle wallet connection and payment
@@ -4289,6 +1820,158 @@ var ZendFiEmbeddedCheckout = class {
   getErrorStyles() {
     return this.getLoadingStyles();
   }
+  /**
+   * Handle bank payment submit (send OTP or verify OTP)
+   */
+  async handleBankSubmit() {
+    const submitBtn = document.getElementById("zendfi-bank-submit");
+    const errorDiv = document.getElementById("zendfi-bank-error");
+    const emailInput = document.getElementById("zendfi-bank-email");
+    const otpContainer = document.getElementById("zendfi-bank-otp-container");
+    const otpInput = document.getElementById("zendfi-bank-otp");
+    if (!submitBtn || !errorDiv || !emailInput) return;
+    errorDiv.style.display = "none";
+    submitBtn.disabled = true;
+    try {
+      if (otpContainer && otpContainer.style.display !== "none" && otpInput) {
+        const otp = otpInput.value.trim();
+        if (otp.length !== 4) {
+          throw new Error("Please enter the 4-digit verification code");
+        }
+        submitBtn.textContent = "Creating order...";
+        const response = await fetch(`${this.config.apiUrl}/api/v1/onramp/create-order`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            customer_email: this.bankPaymentState.customerEmail,
+            otp,
+            fiat_amount: this.checkoutData.amount_usd,
+            currency: this.checkoutData.currency,
+            payment_link_id: this.checkoutData.payment_link_id
+          })
+        });
+        if (!response.ok) {
+          const error = await response.json();
+          throw new Error(error.error || "Failed to create order");
+        }
+        const orderData = await response.json();
+        this.bankPaymentState.orderId = orderData.order_id;
+        this.bankPaymentState.bankDetails = {
+          accountNumber: orderData.bank_account_number,
+          accountName: orderData.bank_account_name,
+          bankName: orderData.bank_name,
+          amount: orderData.fiat_amount
+        };
+        this.render();
+        this.startBankStatusPolling();
+      } else {
+        const email = emailInput.value.trim();
+        if (!email || !email.includes("@")) {
+          throw new Error("Please enter a valid email address");
+        }
+        this.bankPaymentState.customerEmail = email;
+        submitBtn.textContent = "Sending code...";
+        const response = await fetch(`${this.config.apiUrl}/api/v1/onramp/initiate`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            customer_email: email,
+            fiat_amount: this.checkoutData.amount_usd,
+            payment_link_id: this.checkoutData.payment_link_id
+          })
+        });
+        if (!response.ok) {
+          const error = await response.json();
+          throw new Error(error.error || "Failed to send verification code");
+        }
+        if (otpContainer) {
+          otpContainer.style.display = "block";
+        }
+        emailInput.disabled = true;
+        submitBtn.textContent = "Verify Code";
+      }
+    } catch (error) {
+      errorDiv.textContent = error.message;
+      errorDiv.style.display = "block";
+    } finally {
+      submitBtn.disabled = false;
+    }
+  }
+  /**
+   * Start polling bank payment status
+   */
+  startBankStatusPolling() {
+    if (!this.bankPaymentState.orderId) return;
+    let startTime = Date.now();
+    const timerInterval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      const minutes = Math.floor(elapsed / 60);
+      const seconds = elapsed % 60;
+      const timerEl = document.getElementById("zendfi-bank-timer");
+      if (timerEl) {
+        timerEl.textContent = `${minutes}:${seconds.toString().padStart(2, "0")}`;
+      }
+    }, 1e3);
+    const pollInterval = setInterval(async () => {
+      await this.checkBankPaymentStatus();
+    }, 5e3);
+    this.bankPaymentState.pollingInterval = pollInterval;
+    this.bankPaymentState.timerInterval = timerInterval;
+  }
+  /**
+   * Check bank payment status
+   */
+  async checkBankPaymentStatus() {
+    if (!this.bankPaymentState.orderId) return;
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/api/v1/onramp/orders/${this.bankPaymentState.orderId}`
+      );
+      if (!response.ok) return;
+      const order = await response.json();
+      if (order.status === "COMPLETED" || order.status === "completed") {
+        this.handleBankPaymentSuccess(order);
+      }
+    } catch (error) {
+      console.error("Failed to check bank payment status:", error);
+    }
+  }
+  /**
+   * Handle successful bank payment
+   */
+  handleBankPaymentSuccess(order) {
+    if (this.bankPaymentState.pollingInterval) {
+      clearInterval(this.bankPaymentState.pollingInterval);
+    }
+    if (this.bankPaymentState.timerInterval) {
+      clearInterval(this.bankPaymentState.timerInterval);
+    }
+    this.renderSuccess();
+    if (!this.paymentProcessed) {
+      this.paymentProcessed = true;
+      this.config.onSuccess({
+        paymentId: this.checkoutData.payment_id,
+        transactionSignature: order.paj_order_id,
+        amount: order.token_amount,
+        token: this.checkoutData.token,
+        merchantName: this.checkoutData.merchant_name
+      });
+    }
+  }
+  /**
+   * Manually refresh bank payment status
+   */
+  async refreshBankStatus() {
+    const refreshBtn = document.getElementById("zendfi-refresh-status");
+    if (!refreshBtn) return;
+    refreshBtn.disabled = true;
+    refreshBtn.textContent = "\u{1F504} Checking...";
+    await this.checkBankPaymentStatus();
+    setTimeout(() => {
+      refreshBtn.disabled = false;
+      refreshBtn.textContent = "\u{1F504} Refresh Status";
+    }, 1e3);
+  }
 };
 if (typeof window !== "undefined") {
   window.ZendFiEmbeddedCheckout = ZendFiEmbeddedCheckout;
@@ -4424,552 +2107,16 @@ async function processWebhook(a, b, c) {
       checkDuplicate: cfg.checkDuplicate,
       markProcessed: cfg.markProcessed
     };
-    return await processPayload(payload, handlers, fullConfig);
-  } catch (err) {
-    return {
-      success: false,
-      processed: false,
-      error: err.message,
-      statusCode: 500
-    };
-  }
-}
-
-// src/lit-crypto-signer.ts
-var SPENDING_LIMIT_ACTION_CID = "QmXXunoMeNhXhnr4onzBuvnMzDqH8rf1qdM94RKXayypX3";
-var LitCryptoSigner = class {
-  config;
-  litNodeClient = null;
-  connected = false;
-  constructor(config = {}) {
-    this.config = {
-      network: config.network || "datil-dev",
-      apiEndpoint: config.apiEndpoint || "https://api.zendfi.tech",
-      apiKey: config.apiKey || "",
-      debug: config.debug || false
-    };
-  }
-  async connect() {
-    if (this.connected && this.litNodeClient) {
-      return;
-    }
-    this.log("Connecting to Lit Protocol network:", this.config.network);
-    const { LitNodeClient } = await import("@lit-protocol/lit-node-client");
-    this.litNodeClient = new LitNodeClient({
-      litNetwork: this.config.network,
-      debug: this.config.debug
-    });
-    await this.litNodeClient.connect();
-    this.connected = true;
-    this.log("Connected to Lit Protocol");
-  }
-  async disconnect() {
-    if (this.litNodeClient) {
-      await this.litNodeClient.disconnect();
-      this.litNodeClient = null;
-      this.connected = false;
-    }
-  }
-  async signPayment(params) {
-    if (!this.connected || !this.litNodeClient) {
-      throw new Error("Not connected to Lit Protocol. Call connect() first.");
-    }
-    this.log("Signing payment with Lit Protocol");
-    this.log("  Session:", params.sessionId);
-    this.log("  Amount: $" + params.amountUsd);
-    try {
-      let sessionSigs = params.sessionSigs;
-      if (!sessionSigs) {
-        sessionSigs = await this.getSessionSigs(params.pkpPublicKey);
-      }
-      const result = await this.litNodeClient.executeJs({
-        ipfsId: SPENDING_LIMIT_ACTION_CID,
-        sessionSigs,
-        jsParams: {
-          sessionId: params.sessionId,
-          requestedAmountUsd: params.amountUsd,
-          merchantId: params.merchantId,
-          transactionToSign: params.transactionToSign,
-          apiEndpoint: this.config.apiEndpoint,
-          apiKey: this.config.apiKey,
-          pkpPublicKey: params.pkpPublicKey
-        }
-      });
-      this.log("Lit Action result:", result);
-      const response = JSON.parse(result.response);
-      return {
-        success: response.success,
-        signature: response.signature,
-        publicKey: response.publicKey,
-        recid: response.recid,
-        sessionId: response.session_id,
-        amountUsd: response.amount_usd,
-        remainingBudget: response.remaining_budget,
-        cryptoEnforced: response.crypto_enforced ?? true,
-        error: response.error,
-        code: response.code,
-        currentSpent: response.current_spent,
-        limit: response.limit,
-        remaining: response.remaining
-      };
-    } catch (error) {
-      this.log("Lit signing error:", error);
-      return {
-        success: false,
-        cryptoEnforced: true,
-        error: error instanceof Error ? error.message : "Unknown error",
-        code: "LIT_ERROR"
-      };
-    }
-  }
-  async getSessionSigs(pkpPublicKey) {
-    this.log("Generating Lit session signatures");
-    if (typeof window !== "undefined" && window.ethereum) {
-      const { ethers } = await import("ethers");
-      const provider = new ethers.BrowserProvider(window.ethereum);
-      const signer = await provider.getSigner();
-      const { LitAbility, LitPKPResource } = await import("@lit-protocol/auth-helpers");
-      const sessionSigs = await this.litNodeClient.getSessionSigs({
-        pkpPublicKey,
-        chain: "ethereum",
-        expiration: new Date(Date.now() + 1e3 * 60 * 10).toISOString(),
-        resourceAbilityRequests: [
-          {
-            resource: new LitPKPResource("*"),
-            ability: LitAbility.PKPSigning
-          }
-        ],
-        authNeededCallback: async (params) => {
-          const message = params.message;
-          const signature = await signer.signMessage(message);
-          return {
-            sig: signature,
-            derivedVia: "web3.eth.personal.sign",
-            signedMessage: message,
-            address: await signer.getAddress()
-          };
-        }
-      });
-      return sessionSigs;
-    }
-    throw new Error(
-      "No wallet available. In browser, ensure MetaMask or similar is connected. In Node.js, pass pre-generated sessionSigs to signPayment()."
-    );
-  }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[LitCryptoSigner]", ...args);
-    }
-  }
-};
-function requiresLitSigning(session) {
-  return session.crypto_enforced === true || session.mint_pkp === true;
-}
-function encodeTransactionForLit(transaction) {
-  const bytes = transaction instanceof Uint8Array ? transaction : new Uint8Array(transaction);
-  return btoa(String.fromCharCode(...bytes));
-}
-function decodeSignatureFromLit(result) {
-  if (!result.success || !result.signature) {
-    return null;
-  }
-  const hex = result.signature.startsWith("0x") ? result.signature.slice(2) : result.signature;
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return bytes;
-}
-
-// src/helpers/index.ts
-init_cache();
-
-// src/helpers/ai.ts
-var PaymentIntentParser = class {
-  /**
-   * Parse natural language into structured intent
-   */
-  static parse(text) {
-    if (!text || typeof text !== "string") return null;
-    const lowerText = text.toLowerCase().trim();
-    let action = "chat_only";
-    let confidence = 0;
-    if (this.containsPaymentKeywords(lowerText)) {
-      action = "payment";
-      confidence = 0.7;
-      const amount = this.extractAmount(lowerText);
-      const description = this.extractDescription(lowerText);
-      if (amount && description) {
-        confidence = 0.9;
-        return { action, amount, description, confidence, rawText: text };
-      }
-      if (amount) {
-        confidence = 0.8;
-        return { action, amount, confidence, rawText: text };
-      }
-    }
-    if (this.containsSessionKeywords(lowerText)) {
-      action = "create_session";
-      confidence = 0.8;
-      const amount = this.extractAmount(lowerText);
-      return { action, amount, confidence, rawText: text, description: "Session key budget" };
-    }
-    if (this.containsStatusKeywords(lowerText)) {
-      action = lowerText.includes("session") || lowerText.includes("key") ? "check_status" : "check_balance";
-      confidence = 0.9;
-      return { action, confidence, rawText: text };
-    }
-    if (this.containsTopUpKeywords(lowerText)) {
-      action = "topup";
-      confidence = 0.8;
-      const amount = this.extractAmount(lowerText);
-      return { action, amount, confidence, rawText: text };
-    }
-    if (this.containsRevokeKeywords(lowerText)) {
-      action = "revoke";
-      confidence = 0.9;
-      return { action, confidence, rawText: text };
-    }
-    if (this.containsAutonomyKeywords(lowerText)) {
-      action = "enable_autonomy";
-      confidence = 0.8;
-      const amount = this.extractAmount(lowerText);
-      return { action, amount, confidence, rawText: text, description: "Autonomous delegate limit" };
-    }
-    return null;
-  }
-  /**
-   * Generate system prompt for AI models
-   */
-  static generateSystemPrompt(capabilities = {}) {
-    const enabledFeatures = Object.entries({
-      createPayment: capabilities.createPayment !== false,
-      createSessionKey: capabilities.createSessionKey !== false,
-      checkBalance: capabilities.checkBalance !== false,
-      checkStatus: capabilities.checkStatus !== false,
-      topUpSession: capabilities.topUpSession !== false,
-      revokeSession: capabilities.revokeSession !== false,
-      enableAutonomy: capabilities.enableAutonomy !== false
-    }).filter(([_, enabled]) => enabled).map(([feature]) => feature);
-    return `You are a ZendFi payment assistant. You can help users with crypto payments on Solana.
-
-Available Actions:
-${enabledFeatures.includes("createPayment") ? '- Make payments (e.g., "Buy coffee for $5", "Send $20 to merchant")' : ""}
-${enabledFeatures.includes("createSessionKey") ? '- Create session keys (e.g., "Create a session key with $100 budget")' : ""}
-${enabledFeatures.includes("checkBalance") ? `- Check balances (e.g., "What's my balance?", "How much do I have?")` : ""}
-${enabledFeatures.includes("checkStatus") ? '- Check session status (e.g., "Session key status", "How much is left?")' : ""}
-${enabledFeatures.includes("topUpSession") ? '- Top up session keys (e.g., "Add $50 to session key", "Top up with $100")' : ""}
-${enabledFeatures.includes("revokeSession") ? '- Revoke session keys (e.g., "Revoke session key", "Cancel my session")' : ""}
-${enabledFeatures.includes("enableAutonomy") ? '- Enable autonomous mode (e.g., "Enable auto-pay with $25 limit")' : ""}
-
-Response Format:
-Always respond with valid JSON:
-{
-  "action": "payment" | "create_session" | "check_balance" | "check_status" | "topup" | "revoke" | "enable_autonomy" | "chat_only",
-  "amount_usd": <number if applicable>,
-  "description": "<description>",
-  "message": "<friendly response to user>"
-}
-
-Examples:
-User: "Buy coffee for $5"
-You: {"action": "payment", "amount_usd": 5, "description": "coffee", "message": "Sure! Processing your $5 coffee payment..."}
-
-User: "Create a session key with $100"
-You: {"action": "create_session", "amount_usd": 100, "message": "I'll create a session key with a $100 budget..."}
-
-User: "What's my balance?"
-You: {"action": "check_balance", "message": "Let me check your balance..."}
-
-Be helpful, concise, and always respond in valid JSON format.`;
-  }
-  // ============================================
-  // Keyword Detection
-  // ============================================
-  static containsPaymentKeywords(text) {
-    const keywords = [
-      "buy",
-      "purchase",
-      "pay",
-      "send",
-      "transfer",
-      "payment",
-      "order",
-      "checkout",
-      "subscribe",
-      "donate",
-      "tip"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  static containsSessionKeywords(text) {
-    const keywords = [
-      "create session",
-      "new session",
-      "session key",
-      "setup session",
-      "generate session",
-      "make session",
-      "start session"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  static containsStatusKeywords(text) {
-    const keywords = [
-      "status",
-      "balance",
-      "remaining",
-      "left",
-      "how much",
-      "check",
-      "show",
-      "view",
-      "display"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  static containsTopUpKeywords(text) {
-    const keywords = [
-      "top up",
-      "topup",
-      "add funds",
-      "add money",
-      "fund",
-      "increase",
-      "reload",
-      "refill"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  static containsRevokeKeywords(text) {
-    const keywords = [
-      "revoke",
-      "cancel",
-      "disable",
-      "remove",
-      "delete",
-      "stop",
-      "end",
-      "terminate"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  static containsAutonomyKeywords(text) {
-    const keywords = [
-      "autonomous",
-      "auto",
-      "automatic",
-      "delegate",
-      "enable auto",
-      "auto-sign",
-      "auto sign",
-      "auto-pay",
-      "auto pay"
-    ];
-    return keywords.some((kw) => text.includes(kw));
-  }
-  // ============================================
-  // Amount Extraction
-  // ============================================
-  static extractAmount(text) {
-    const dollarMatch = text.match(/\$\s*(\d+(?:\.\d{1,2})?)/);
-    if (dollarMatch) {
-      return parseFloat(dollarMatch[1]);
-    }
-    const usdMatch = text.match(/(\d+(?:\.\d{1,2})?)\s*(?:usd|usdc|dollars?)/i);
-    if (usdMatch) {
-      return parseFloat(usdMatch[1]);
-    }
-    const numberMatch = text.match(/(\d+(?:\.\d{1,2})?)/);
-    if (numberMatch) {
-      const num = parseFloat(numberMatch[1]);
-      if (num > 0 && num < 1e5) {
-        return num;
-      }
-    }
-    return void 0;
-  }
-  // ============================================
-  // Description Extraction
-  // ============================================
-  static extractDescription(text) {
-    const lowerText = text.toLowerCase();
-    const items = {
-      "coffee": ["coffee", "espresso", "latte", "cappuccino"],
-      "food": ["food", "meal", "lunch", "dinner", "breakfast"],
-      "drink": ["drink", "beverage", "soda", "juice"],
-      "book": ["book", "ebook", "magazine"],
-      "subscription": ["subscription", "membership", "plan"],
-      "tip": ["tip", "gratuity"],
-      "donation": ["donate", "donation", "contribute"],
-      "game": ["game", "gaming"],
-      "music": ["music", "song", "album"],
-      "video": ["video", "movie", "film"]
-    };
-    for (const [item, keywords] of Object.entries(items)) {
-      if (keywords.some((kw) => lowerText.includes(kw))) {
-        return item;
-      }
-    }
-    const forMatch = text.match(/for\s+(.+?)(?:\s+\$|\s+usd|$)/i);
-    if (forMatch && forMatch[1]) {
-      const desc = forMatch[1].trim();
-      if (desc.length > 0 && desc.length < 50) {
-        return desc;
-      }
-    }
-    return void 0;
-  }
-};
-var OpenAIAdapter = class {
-  constructor(apiKey, model = "gpt-4o-mini", capabilities) {
-    this.apiKey = apiKey;
-    this.model = model;
-    this.capabilities = capabilities;
-  }
-  async chat(message, conversationHistory = []) {
-    const systemPrompt = PaymentIntentParser.generateSystemPrompt(this.capabilities);
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages: [
-          { role: "system", content: systemPrompt },
-          ...conversationHistory,
-          { role: "user", content: message }
-        ],
-        temperature: 0.7,
-        max_tokens: 500
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    const text = data.choices[0]?.message?.content || "";
-    let intent = null;
-    try {
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        intent = {
-          action: parsed.action || "chat_only",
-          amount: parsed.amount_usd,
-          description: parsed.description,
-          confidence: 0.9,
-          rawText: text,
-          metadata: { message: parsed.message }
-        };
-      }
-    } catch {
-      intent = PaymentIntentParser.parse(text);
-    }
-    return { text, intent, raw: data };
-  }
-};
-var AnthropicAdapter = class {
-  constructor(apiKey, model = "claude-3-5-sonnet-20241022", capabilities) {
-    this.apiKey = apiKey;
-    this.model = model;
-    this.capabilities = capabilities;
-  }
-  async chat(message, conversationHistory = []) {
-    const systemPrompt = PaymentIntentParser.generateSystemPrompt(this.capabilities);
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01",
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        model: this.model,
-        system: systemPrompt,
-        messages: [
-          ...conversationHistory.map((msg) => ({
-            role: msg.role === "user" ? "user" : "assistant",
-            content: msg.content
-          })),
-          { role: "user", content: message }
-        ],
-        max_tokens: 500
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    const text = data.content[0]?.text || "";
-    let intent = null;
-    try {
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        intent = {
-          action: parsed.action || "chat_only",
-          amount: parsed.amount_usd,
-          description: parsed.description,
-          confidence: 0.9,
-          rawText: text,
-          metadata: { message: parsed.message }
-        };
-      }
-    } catch {
-      intent = PaymentIntentParser.parse(text);
-    }
-    return { text, intent, raw: data };
-  }
-};
-var GeminiAdapter = class {
-  constructor(apiKey, model = "gemini-2.0-flash-exp", capabilities) {
-    this.apiKey = apiKey;
-    this.model = model;
-    this.capabilities = capabilities;
-  }
-  async chat(message) {
-    const systemPrompt = PaymentIntentParser.generateSystemPrompt(this.capabilities);
-    const fullPrompt = `${systemPrompt}
-
-User: ${message}`;
-    const response = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          contents: [{ parts: [{ text: fullPrompt }] }]
-        })
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    const text = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
-    let intent = null;
-    try {
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        intent = {
-          action: parsed.action || "chat_only",
-          amount: parsed.amount_usd,
-          description: parsed.description,
-          confidence: 0.9,
-          rawText: text,
-          metadata: { message: parsed.message }
-        };
-      }
-    } catch {
-      intent = PaymentIntentParser.parse(text);
-    }
-    return { text, intent, raw: data };
+    return await processPayload(payload, handlers, fullConfig);
+  } catch (err) {
+    return {
+      success: false,
+      processed: false,
+      error: err.message,
+      statusCode: 500
+    };
   }
-};
+}
 
 // src/helpers/wallet.ts
 var WalletConnector = class _WalletConnector {
@@ -5263,323 +2410,6 @@ function createWalletHook() {
   };
 }
 
-// src/helpers/security.ts
-var PINValidator = class {
-  /**
-   * Validate PIN strength and format
-   */
-  static validate(pin) {
-    const errors = [];
-    const suggestions = [];
-    if (!pin || pin.length < 4) {
-      errors.push("PIN must be at least 4 digits");
-    }
-    if (pin.length > 12) {
-      errors.push("PIN must be at most 12 digits");
-    }
-    if (!/^\d+$/.test(pin)) {
-      errors.push("PIN must contain only digits");
-    }
-    if (this.isWeakPattern(pin)) {
-      errors.push("PIN is too simple");
-      suggestions.push("Avoid sequential numbers (1234) or repeated digits (1111)");
-    }
-    let strength = "strong";
-    if (errors.length > 0) {
-      strength = "weak";
-    } else if (pin.length <= 4 || this.hasRepeatedDigits(pin)) {
-      strength = "weak";
-      suggestions.push("Use at least 6 digits for better security");
-    } else if (pin.length <= 6) {
-      strength = "medium";
-      suggestions.push("Use 8+ digits for maximum security");
-    }
-    return {
-      valid: errors.length === 0,
-      strength,
-      errors,
-      suggestions
-    };
-  }
-  /**
-   * Check PIN strength (0-100 score)
-   */
-  static strengthScore(pin) {
-    if (!pin) return 0;
-    let score = 0;
-    score += Math.min(pin.length * 10, 50);
-    const uniqueDigits = new Set(pin).size;
-    score += uniqueDigits * 5;
-    if (!this.isSequential(pin)) {
-      score += 20;
-    }
-    if (!this.hasRepeatedDigits(pin)) {
-      score += 10;
-    }
-    return Math.min(score, 100);
-  }
-  /**
-   * Generate a secure random PIN
-   */
-  static generateSecureRandom(length = 6) {
-    if (length < 4 || length > 12) {
-      throw new Error("PIN length must be between 4 and 12");
-    }
-    const array = new Uint32Array(length);
-    crypto.getRandomValues(array);
-    const pin = Array.from(array).map((num) => num % 10).join("");
-    if (this.isWeakPattern(pin)) {
-      return this.generateSecureRandom(length);
-    }
-    return pin;
-  }
-  /**
-   * Check for weak patterns
-   */
-  static isWeakPattern(pin) {
-    if (this.isSequential(pin)) return true;
-    if (/^(\d)\1+$/.test(pin)) return true;
-    const commonPatterns = [
-      "1234",
-      "4321",
-      "1111",
-      "2222",
-      "3333",
-      "4444",
-      "5555",
-      "6666",
-      "7777",
-      "8888",
-      "9999",
-      "0000",
-      "1212",
-      "2323",
-      "0123",
-      "3210",
-      "9876",
-      "6789"
-    ];
-    return commonPatterns.some((pattern) => pin.includes(pattern));
-  }
-  /**
-   * Check if PIN is sequential
-   */
-  static isSequential(pin) {
-    for (let i = 1; i < pin.length; i++) {
-      const diff = parseInt(pin[i]) - parseInt(pin[i - 1]);
-      if (Math.abs(diff) !== 1) return false;
-    }
-    return true;
-  }
-  /**
-   * Check if PIN has repeated digits
-   */
-  static hasRepeatedDigits(pin) {
-    return /(\d)\1{2,}/.test(pin);
-  }
-  /**
-   * Hash PIN for storage (if needed)
-   * Note: For device-bound keys, the PIN is used for key derivation, not storage
-   */
-  static async hashPIN(pin, salt) {
-    const actualSalt = salt || crypto.getRandomValues(new Uint8Array(16));
-    const encoder = new TextEncoder();
-    const data = encoder.encode(pin + actualSalt);
-    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-};
-var PINRateLimiter = class {
-  attempts = /* @__PURE__ */ new Map();
-  locked = /* @__PURE__ */ new Map();
-  maxAttempts;
-  windowMs;
-  lockoutMs;
-  constructor(config = {}) {
-    this.maxAttempts = config.maxAttempts || 3;
-    this.windowMs = config.windowMs || 6e4;
-    this.lockoutMs = config.lockoutMs || 3e5;
-  }
-  /**
-   * Check if attempt is allowed
-   */
-  async checkAttempt(sessionKeyId) {
-    const now = Date.now();
-    const lockoutUntil = this.locked.get(sessionKeyId);
-    if (lockoutUntil && now < lockoutUntil) {
-      const lockoutSeconds = Math.ceil((lockoutUntil - now) / 1e3);
-      return {
-        allowed: false,
-        remainingAttempts: 0,
-        lockoutSeconds
-      };
-    }
-    if (lockoutUntil && now >= lockoutUntil) {
-      this.locked.delete(sessionKeyId);
-      this.attempts.delete(sessionKeyId);
-    }
-    const recentAttempts = this.getRecentAttempts(sessionKeyId, now);
-    const remainingAttempts = this.maxAttempts - recentAttempts.length;
-    if (remainingAttempts <= 0) {
-      this.locked.set(sessionKeyId, now + this.lockoutMs);
-      return {
-        allowed: false,
-        remainingAttempts: 0,
-        lockoutSeconds: Math.ceil(this.lockoutMs / 1e3)
-      };
-    }
-    return {
-      allowed: true,
-      remainingAttempts
-    };
-  }
-  /**
-   * Record a failed attempt
-   */
-  recordFailedAttempt(sessionKeyId) {
-    const now = Date.now();
-    const attempts = this.attempts.get(sessionKeyId) || [];
-    attempts.push(now);
-    this.attempts.set(sessionKeyId, attempts);
-  }
-  /**
-   * Record a successful attempt (clears history)
-   */
-  recordSuccessfulAttempt(sessionKeyId) {
-    this.attempts.delete(sessionKeyId);
-    this.locked.delete(sessionKeyId);
-  }
-  /**
-   * Get recent attempts within window
-   */
-  getRecentAttempts(sessionKeyId, now) {
-    const attempts = this.attempts.get(sessionKeyId) || [];
-    const cutoff = now - this.windowMs;
-    const recent = attempts.filter((timestamp) => timestamp > cutoff);
-    if (recent.length !== attempts.length) {
-      this.attempts.set(sessionKeyId, recent);
-    }
-    return recent;
-  }
-  /**
-   * Clear all rate limit data
-   */
-  clear() {
-    this.attempts.clear();
-    this.locked.clear();
-  }
-  /**
-   * Check lockout status
-   */
-  isLockedOut(sessionKeyId) {
-    const lockoutUntil = this.locked.get(sessionKeyId);
-    return lockoutUntil ? Date.now() < lockoutUntil : false;
-  }
-  /**
-   * Get remaining lockout time
-   */
-  getRemainingLockoutTime(sessionKeyId) {
-    const lockoutUntil = this.locked.get(sessionKeyId);
-    if (!lockoutUntil) return 0;
-    return Math.max(0, lockoutUntil - Date.now());
-  }
-};
-var SecureStorage = class {
-  /**
-   * Store data with encryption (basic)
-   * For production, consider using Web Crypto API with user-derived keys
-   */
-  static async setEncrypted(key, value, secret) {
-    const encrypted = await this.encrypt(value, secret);
-    localStorage.setItem(key, JSON.stringify(encrypted));
-  }
-  /**
-   * Retrieve encrypted data
-   */
-  static async getEncrypted(key, secret) {
-    const stored = localStorage.getItem(key);
-    if (!stored) return null;
-    try {
-      const encrypted = JSON.parse(stored);
-      return await this.decrypt(encrypted, secret);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Encrypt string with AES-GCM
-   */
-  static async encrypt(plaintext, secret) {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(plaintext);
-    const key = await this.deriveKey(secret);
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const encrypted = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv },
-      key,
-      data
-    );
-    return {
-      ciphertext: btoa(String.fromCharCode(...new Uint8Array(encrypted))),
-      iv: btoa(String.fromCharCode(...iv))
-    };
-  }
-  /**
-   * Decrypt AES-GCM ciphertext
-   */
-  static async decrypt(encrypted, secret) {
-    const key = await this.deriveKey(secret);
-    const iv = Uint8Array.from(atob(encrypted.iv), (c) => c.charCodeAt(0));
-    const ciphertext = Uint8Array.from(atob(encrypted.ciphertext), (c) => c.charCodeAt(0));
-    const decrypted = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv },
-      key,
-      ciphertext
-    );
-    const decoder = new TextDecoder();
-    return decoder.decode(decrypted);
-  }
-  /**
-   * Derive encryption key from secret
-   */
-  static async deriveKey(secret) {
-    const encoder = new TextEncoder();
-    const keyMaterial = await crypto.subtle.importKey(
-      "raw",
-      encoder.encode(secret),
-      { name: "PBKDF2" },
-      false,
-      ["deriveBits", "deriveKey"]
-    );
-    return await crypto.subtle.deriveKey(
-      {
-        name: "PBKDF2",
-        salt: encoder.encode("zendfi-secure-storage"),
-        iterations: 1e5,
-        hash: "SHA-256"
-      },
-      keyMaterial,
-      { name: "AES-GCM", length: 256 },
-      false,
-      ["encrypt", "decrypt"]
-    );
-  }
-  /**
-   * Clear all secure storage
-   */
-  static clearAll(namespace = "zendfi") {
-    const keysToRemove = [];
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (key?.startsWith(namespace)) {
-        keysToRemove.push(key);
-      }
-    }
-    keysToRemove.forEach((key) => localStorage.removeItem(key));
-  }
-};
-
 // src/helpers/polling.ts
 var TransactionPoller = class {
   /**
@@ -5840,403 +2670,6 @@ var TransactionMonitor = class {
   }
 };
 
-// src/helpers/recovery.ts
-var RetryStrategy = class {
-  /**
-   * Execute function with retry logic
-   */
-  static async withRetry(fn, options = {}) {
-    const {
-      maxAttempts = 3,
-      backoffMs = 1e3,
-      backoffMultiplier = 2,
-      maxBackoffMs = 3e4,
-      shouldRetry = () => true,
-      onRetry
-    } = options;
-    let lastError = null;
-    let currentBackoff = backoffMs;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        lastError = error;
-        if (attempt === maxAttempts || !shouldRetry(error, attempt)) {
-          throw error;
-        }
-        const jitter = Math.random() * 0.3 * currentBackoff;
-        const nextDelay = Math.min(currentBackoff + jitter, maxBackoffMs);
-        onRetry?.(error, attempt, nextDelay);
-        await this.sleep(nextDelay);
-        currentBackoff *= backoffMultiplier;
-      }
-    }
-    throw lastError || new Error("Retry failed");
-  }
-  /**
-   * Retry with linear backoff
-   */
-  static async withLinearRetry(fn, maxAttempts = 3, delayMs = 1e3) {
-    return this.withRetry(fn, {
-      maxAttempts,
-      backoffMs: delayMs,
-      backoffMultiplier: 1
-      // Linear
-    });
-  }
-  /**
-   * Retry with custom backoff function
-   */
-  static async withCustomBackoff(fn, backoffFn, maxAttempts = 3) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        lastError = error;
-        if (attempt === maxAttempts) {
-          throw error;
-        }
-        const delay = backoffFn(attempt);
-        await this.sleep(delay);
-      }
-    }
-    throw lastError || new Error("Retry failed");
-  }
-  /**
-   * Check if error is retryable
-   */
-  static isRetryableError(error) {
-    if (error.name === "NetworkError" || error.message?.includes("network")) {
-      return true;
-    }
-    if (error.name === "TimeoutError" || error.message?.includes("timeout")) {
-      return true;
-    }
-    if (error.status === 429 || error.code === "RATE_LIMIT_EXCEEDED") {
-      return true;
-    }
-    if (error.status >= 500 && error.status < 600) {
-      return true;
-    }
-    if (error.message?.includes("blockhash") || error.message?.includes("recent")) {
-      return true;
-    }
-    return false;
-  }
-  static sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-var ErrorRecovery = class {
-  /**
-   * Recover from network errors with retry
-   */
-  static async recoverFromNetworkError(fn, maxAttempts = 3) {
-    return RetryStrategy.withRetry(fn, {
-      maxAttempts,
-      backoffMs: 2e3,
-      shouldRetry: (error) => {
-        return error.name === "NetworkError" || error.message?.includes("network") || error.message?.includes("fetch");
-      },
-      onRetry: (error, attempt, nextDelay) => {
-        console.warn(
-          `Network error (attempt ${attempt}), retrying in ${nextDelay}ms:`,
-          error.message
-        );
-      }
-    });
-  }
-  /**
-   * Recover from rate limit errors with exponential backoff
-   */
-  static async recoverFromRateLimit(fn, maxAttempts = 5) {
-    return RetryStrategy.withRetry(fn, {
-      maxAttempts,
-      backoffMs: 5e3,
-      // Start with 5 seconds
-      backoffMultiplier: 2,
-      maxBackoffMs: 6e4,
-      // Cap at 1 minute
-      shouldRetry: (error) => {
-        return error.status === 429 || error.code === "RATE_LIMIT_EXCEEDED";
-      },
-      onRetry: (attempt, nextDelay) => {
-        console.warn(
-          `Rate limited (attempt ${attempt}), waiting ${nextDelay}ms before retry`
-        );
-      }
-    });
-  }
-  /**
-   * Recover from Solana RPC errors (blockhash, etc.)
-   */
-  static async recoverFromRPCError(fn, maxAttempts = 3) {
-    return RetryStrategy.withRetry(fn, {
-      maxAttempts,
-      backoffMs: 1e3,
-      shouldRetry: (error) => {
-        const message = error.message?.toLowerCase() || "";
-        return message.includes("blockhash") || message.includes("recent") || message.includes("slot") || message.includes("rpc");
-      },
-      onRetry: (error, attempt, nextDelay) => {
-        console.warn(
-          `RPC error (attempt ${attempt}), retrying in ${nextDelay}ms:`,
-          error.message
-        );
-      }
-    });
-  }
-  /**
-   * Recover from timeout errors
-   */
-  static async recoverFromTimeout(fn, timeoutMs = 3e4, maxAttempts = 2) {
-    return RetryStrategy.withRetry(
-      () => this.withTimeout(fn, timeoutMs),
-      {
-        maxAttempts,
-        backoffMs: 5e3,
-        shouldRetry: (error) => {
-          return error.name === "TimeoutError" || error.message?.includes("timeout");
-        }
-      }
-    );
-  }
-  /**
-   * Add timeout to async function
-   */
-  static async withTimeout(fn, timeoutMs) {
-    return Promise.race([
-      fn(),
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Operation timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-      })
-    ]);
-  }
-  /**
-   * Circuit breaker pattern for repeated failures
-   */
-  static createCircuitBreaker(fn, options = {}) {
-    const {
-      failureThreshold = 5,
-      resetTimeoutMs = 6e4,
-      onStateChange
-    } = options;
-    let state = "closed";
-    let failureCount = 0;
-    let lastFailureTime = 0;
-    let resetTimer = null;
-    return async () => {
-      if (state === "open" && Date.now() - lastFailureTime > resetTimeoutMs) {
-        state = "half-open";
-        onStateChange?.("half-open");
-      }
-      if (state === "open") {
-        throw new Error("Circuit breaker is OPEN - too many failures");
-      }
-      try {
-        const result = await fn();
-        if (state === "half-open") {
-          state = "closed";
-          onStateChange?.("closed");
-        }
-        failureCount = 0;
-        return result;
-      } catch (error) {
-        failureCount++;
-        lastFailureTime = Date.now();
-        if (failureCount >= failureThreshold) {
-          state = "open";
-          onStateChange?.("open");
-          if (resetTimer) clearTimeout(resetTimer);
-          resetTimer = setTimeout(() => {
-            state = "half-open";
-            onStateChange?.("half-open");
-          }, resetTimeoutMs);
-        }
-        throw error;
-      }
-    };
-  }
-  /**
-   * Fallback to alternative function on error
-   */
-  static async withFallback(primaryFn, fallbackFn, shouldFallback = () => true) {
-    try {
-      return await primaryFn();
-    } catch (error) {
-      if (shouldFallback(error)) {
-        console.warn("Primary function failed, using fallback:", error.message);
-        return await fallbackFn();
-      }
-      throw error;
-    }
-  }
-  /**
-   * Graceful degradation - return partial result on error
-   */
-  static async withGracefulDegradation(fn, defaultValue, onError) {
-    try {
-      return await fn();
-    } catch (error) {
-      onError?.(error);
-      console.warn("Operation failed, returning default value:", error.message);
-      return defaultValue;
-    }
-  }
-};
-
-// src/helpers/lifecycle.ts
-var SessionKeyLifecycle = class {
-  constructor(client, config = {}) {
-    this.client = client;
-    this.config = config;
-    if (config.autoCleanup && typeof window !== "undefined") {
-      window.addEventListener("beforeunload", () => {
-        this.cleanup().catch(console.error);
-      });
-    }
-  }
-  sessionKeyId = null;
-  sessionWallet = null;
-  /**
-   * Create and fund session key in one call
-   * Handles: keypair generation → encryption → backend registration
-   * Note: The SDK now handles all crypto internally
-   */
-  async createAndFund(config) {
-    const pin = this.config.pinProvider ? await this.config.pinProvider() : await this.promptForPIN("Create PIN for session key");
-    const response = await this.client.sessionKeys.create({
-      userWallet: config.userWallet,
-      agentId: config.agentId,
-      agentName: config.agentName,
-      limitUSDC: config.limitUsdc,
-      durationDays: config.durationDays || 7,
-      pin,
-      // SDK handles encryption internally
-      generateRecoveryQR: false
-    });
-    this.sessionKeyId = response.sessionKeyId;
-    this.sessionWallet = response.sessionWallet;
-    if (config.onApprovalNeeded) {
-      await config.onApprovalNeeded(`Fund session wallet: ${this.sessionWallet}`);
-    }
-    return {
-      sessionKeyId: this.sessionKeyId,
-      sessionWallet: this.sessionWallet
-    };
-  }
-  /**
-   * Make a payment using the session key
-   * Uses the new SDK's makePayment which handles caching internally
-   */
-  async pay(amount, description) {
-    if (!this.sessionKeyId || !this.sessionWallet) {
-      throw new Error("No active session key. Call createAndFund() first.");
-    }
-    const pin = this.config.pinProvider ? await this.config.pinProvider() : void 0;
-    const result = await this.client.sessionKeys.makePayment({
-      sessionKeyId: this.sessionKeyId,
-      amount,
-      recipient: this.sessionWallet,
-      description,
-      pin
-      // SDK will only use PIN if needed
-    });
-    return {
-      paymentId: result.paymentId,
-      status: result.status,
-      signature: result.signature
-    };
-  }
-  /**
-   * Check session key status
-   */
-  async getStatus() {
-    if (!this.sessionKeyId) {
-      throw new Error("No active session key");
-    }
-    return await this.client.sessionKeys.getStatus(this.sessionKeyId);
-  }
-  /**
-   * Top up session key
-   * @deprecated Device-bound session keys are funded directly by the user.
-   * Use the session wallet address to send funds directly.
-   */
-  async topUp(_amount, _userWallet, _onApprovalNeeded) {
-    if (!this.sessionWallet) {
-      throw new Error("No active session key");
-    }
-    console.warn(
-      `topUp() is deprecated for device-bound session keys. Send funds directly to the session wallet: ${this.sessionWallet}`
-    );
-  }
-  /**
-   * Revoke session key
-   */
-  async revoke() {
-    if (!this.sessionKeyId) {
-      throw new Error("No active session key");
-    }
-    await this.client.sessionKeys.revoke(this.sessionKeyId);
-    await this.cleanup();
-  }
-  /**
-   * Cleanup (clear cache, reset state)
-   */
-  async cleanup() {
-    if (this.config.cache && this.sessionKeyId) {
-      await this.config.cache.invalidate(this.sessionKeyId);
-    }
-    if (this.sessionKeyId) {
-      this.client.sessionKeys.clearCache(this.sessionKeyId);
-    }
-    this.sessionKeyId = null;
-    this.sessionWallet = null;
-  }
-  /**
-   * Get current session key ID
-   */
-  getSessionKeyId() {
-    return this.sessionKeyId;
-  }
-  /**
-   * Check if session is active
-   */
-  isActive() {
-    return this.sessionKeyId !== null;
-  }
-  // ============================================
-  // Private Helpers
-  // ============================================
-  async promptForPIN(message) {
-    if (typeof window !== "undefined" && window.prompt) {
-      const pin = window.prompt(message);
-      if (!pin) {
-        throw new Error("PIN required");
-      }
-      return pin;
-    }
-    throw new Error("PIN provider not configured and no browser prompt available");
-  }
-};
-async function setupQuickSessionKey(client, config) {
-  const { SessionKeyCache: SessionKeyCache2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-  const lifecycle = new SessionKeyLifecycle(client, {
-    cache: new SessionKeyCache2({ storage: "localStorage", ttl: 36e5 }),
-    autoCleanup: true
-  });
-  await lifecycle.createAndFund({
-    userWallet: config.userWallet,
-    agentId: config.agentId,
-    limitUsdc: config.budgetUsdc,
-    onApprovalNeeded: config.onApproval
-  });
-  return lifecycle;
-}
-
 // src/helpers/dev.ts
 var DevTools = class {
   static debugEnabled = false;
@@ -6318,8 +2751,8 @@ var DevTools = class {
     if (!this.isDevelopment()) {
       throw new Error("Test session keys can only be created in development");
     }
-    const { Keypair: Keypair2 } = await this.getSolanaWeb3();
-    const keypair = Keypair2.generate();
+    const { Keypair } = await this.getSolanaWeb3();
+    const keypair = Keypair.generate();
     return {
       sessionKeyId: this.generateTestId("sk_test"),
       sessionWallet: keypair.publicKey.toString(),
@@ -6581,41 +3014,17 @@ var PerformanceMonitor = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AgentAPI,
-  AnthropicAdapter,
   ApiError,
   AuthenticationError,
-  AutonomyAPI,
   ConfigLoader,
   DevTools,
-  DeviceBoundSessionKey,
-  DeviceFingerprintGenerator,
   ERROR_CODES,
-  ErrorRecovery,
-  GeminiAdapter,
   InterceptorManager,
-  LitCryptoSigner,
   NetworkError,
-  OpenAIAdapter,
-  PINRateLimiter,
-  PINValidator,
   PaymentError,
-  PaymentIntentParser,
-  PaymentIntentsAPI,
   PerformanceMonitor,
-  PricingAPI,
-  QuickCaches,
   RateLimitError,
   RateLimiter,
-  RecoveryQRGenerator,
-  RetryStrategy,
-  SPENDING_LIMIT_ACTION_CID,
-  SecureStorage,
-  SessionKeyCache,
-  SessionKeyCrypto,
-  SessionKeyLifecycle,
-  SessionKeysAPI,
-  SmartPaymentsAPI,
   TransactionMonitor,
   TransactionPoller,
   ValidationError,
@@ -6624,25 +3033,17 @@ var PerformanceMonitor = class {
   ZendFiClient,
   ZendFiEmbeddedCheckout,
   ZendFiError,
-  asAgentKeyId,
-  asEscrowId,
   asInstallmentPlanId,
-  asIntentId,
   asInvoiceId,
   asMerchantId,
   asPaymentId,
   asPaymentLinkCode,
-  asSessionId,
   asSubscriptionId,
   createWalletHook,
   createZendFiError,
-  decodeSignatureFromLit,
-  encodeTransactionForLit,
   generateIdempotencyKey,
   isZendFiError,
   processWebhook,
-  requiresLitSigning,
-  setupQuickSessionKey,
   sleep,
   verifyExpressWebhook,
   verifyNextWebhook,