@zendfi/sdk 0.8.4 → 1.0.1

package/dist/helpers/index.js

@@ -0,0 +1,944 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/helpers/index.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  DevTools: () => DevTools,
+  PerformanceMonitor: () => PerformanceMonitor,
+  TransactionMonitor: () => TransactionMonitor,
+  TransactionPoller: () => TransactionPoller,
+  WalletConnector: () => WalletConnector,
+  createWalletHook: () => createWalletHook
+});
+module.exports = __toCommonJS(helpers_exports);
+
+// src/helpers/wallet.ts
+var WalletConnector = class _WalletConnector {
+  static connectedWallet = null;
+  /**
+   * Detect and connect to a Solana wallet
+   */
+  static async detectAndConnect(config = {}) {
+    if (this.connectedWallet && this.connectedWallet.isConnected()) {
+      return this.connectedWallet;
+    }
+    const detected = this.detectWallets();
+    if (detected.length === 0) {
+      if (config.showInstallPrompt !== false) {
+        this.showInstallPrompt();
+      }
+      throw new Error("No Solana wallet detected. Please install Phantom, Solflare, or Backpack.");
+    }
+    let selectedProvider = detected[0];
+    if (config.preferredProvider && detected.includes(config.preferredProvider)) {
+      selectedProvider = config.preferredProvider;
+    }
+    const wallet = await this.connectToProvider(selectedProvider);
+    this.connectedWallet = wallet;
+    return wallet;
+  }
+  /**
+   * Detect available Solana wallets
+   */
+  static detectWallets() {
+    const detected = [];
+    if (typeof window === "undefined") return detected;
+    if (window.solana?.isPhantom) detected.push("phantom");
+    if (window.solflare?.isSolflare) detected.push("solflare");
+    if (window.backpack?.isBackpack) detected.push("backpack");
+    if (window.coinbaseSolana) detected.push("coinbase");
+    if (window.trustwallet?.solana) detected.push("trust");
+    return detected;
+  }
+  /**
+   * Connect to a specific wallet provider
+   */
+  static async connectToProvider(provider) {
+    if (typeof window === "undefined") {
+      throw new Error("Wallet connection only works in browser environment");
+    }
+    let adapter;
+    switch (provider) {
+      case "phantom":
+        adapter = window.solana;
+        if (!adapter?.isPhantom) {
+          throw new Error("Phantom wallet not found");
+        }
+        break;
+      case "solflare":
+        adapter = window.solflare;
+        if (!adapter?.isSolflare) {
+          throw new Error("Solflare wallet not found");
+        }
+        break;
+      case "backpack":
+        adapter = window.backpack;
+        if (!adapter?.isBackpack) {
+          throw new Error("Backpack wallet not found");
+        }
+        break;
+      case "coinbase":
+        adapter = window.coinbaseSolana;
+        if (!adapter) {
+          throw new Error("Coinbase Wallet not found");
+        }
+        break;
+      case "trust":
+        adapter = window.trustwallet?.solana;
+        if (!adapter) {
+          throw new Error("Trust Wallet not found");
+        }
+        break;
+      default:
+        throw new Error(`Unknown wallet provider: ${provider}`);
+    }
+    try {
+      const response = await adapter.connect();
+      const publicKey = response.publicKey || adapter.publicKey;
+      if (!publicKey) {
+        throw new Error("Failed to get wallet public key");
+      }
+      const connectedWallet = {
+        address: publicKey.toString(),
+        provider,
+        publicKey,
+        signTransaction: async (tx) => {
+          return await adapter.signTransaction(tx);
+        },
+        signAllTransactions: async (txs) => {
+          if (adapter.signAllTransactions) {
+            return await adapter.signAllTransactions(txs);
+          }
+          const signed = [];
+          for (const tx of txs) {
+            signed.push(await adapter.signTransaction(tx));
+          }
+          return signed;
+        },
+        signMessage: async (message) => {
+          if (adapter.signMessage) {
+            return await adapter.signMessage(message);
+          }
+          throw new Error(`${provider} does not support message signing`);
+        },
+        disconnect: async () => {
+          if (adapter.disconnect) {
+            await adapter.disconnect();
+          }
+          _WalletConnector.connectedWallet = null;
+        },
+        isConnected: () => {
+          return adapter.isConnected ?? false;
+        },
+        raw: adapter
+      };
+      return connectedWallet;
+    } catch (error) {
+      throw new Error(`Failed to connect to ${provider}: ${error.message}`);
+    }
+  }
+  /**
+   * Sign and submit a transaction
+   */
+  static async signAndSubmit(transaction, wallet, connection) {
+    const signedTx = await wallet.signTransaction(transaction);
+    const signature = await connection.sendRawTransaction(signedTx.serialize(), {
+      skipPreflight: false,
+      preflightCommitment: "confirmed"
+    });
+    return { signature };
+  }
+  /**
+   * Get current connected wallet
+   */
+  static getConnectedWallet() {
+    return this.connectedWallet;
+  }
+  /**
+   * Disconnect current wallet
+   */
+  static async disconnect() {
+    if (this.connectedWallet) {
+      await this.connectedWallet.disconnect();
+      this.connectedWallet = null;
+    }
+  }
+  /**
+   * Listen for wallet connection changes
+   */
+  static onAccountChange(callback) {
+    if (typeof window === "undefined") {
+      return () => {
+      };
+    }
+    const cleanupFns = [];
+    if (window.solana?.on) {
+      window.solana.on("accountChanged", callback);
+      cleanupFns.push(() => {
+        window.solana?.removeListener("accountChanged", callback);
+      });
+    }
+    if (window.solflare?.on) {
+      window.solflare.on("accountChanged", callback);
+      cleanupFns.push(() => {
+        window.solflare?.removeListener("accountChanged", callback);
+      });
+    }
+    return () => {
+      cleanupFns.forEach((fn) => fn());
+    };
+  }
+  /**
+   * Listen for wallet disconnection
+   */
+  static onDisconnect(callback) {
+    if (typeof window === "undefined") {
+      return () => {
+      };
+    }
+    const cleanupFns = [];
+    if (window.solana?.on) {
+      window.solana.on("disconnect", callback);
+      cleanupFns.push(() => {
+        window.solana?.removeListener("disconnect", callback);
+      });
+    }
+    if (window.solflare?.on) {
+      window.solflare.on("disconnect", callback);
+      cleanupFns.push(() => {
+        window.solflare?.removeListener("disconnect", callback);
+      });
+    }
+    return () => {
+      cleanupFns.forEach((fn) => fn());
+    };
+  }
+  /**
+   * Show install prompt UI
+   */
+  static showInstallPrompt() {
+    const message = `
+No Solana wallet detected!
+
+Install one of these wallets:
+\u2022 Phantom: https://phantom.app
+\u2022 Solflare: https://solflare.com
+\u2022 Backpack: https://backpack.app
+    `.trim();
+    console.warn(message);
+    if (typeof window !== "undefined") {
+      const userChoice = window.confirm(
+        "No Solana wallet detected.\n\nWould you like to install Phantom wallet?"
+      );
+      if (userChoice) {
+        window.open("https://phantom.app", "_blank");
+      }
+    }
+  }
+  /**
+   * Check if wallet is installed
+   */
+  static isWalletInstalled(provider) {
+    return this.detectWallets().includes(provider);
+  }
+  /**
+   * Get wallet download URL
+   */
+  static getWalletUrl(provider) {
+    const urls = {
+      phantom: "https://phantom.app",
+      solflare: "https://solflare.com",
+      backpack: "https://backpack.app",
+      coinbase: "https://www.coinbase.com/wallet",
+      trust: "https://trustwallet.com"
+    };
+    return urls[provider];
+  }
+};
+function createWalletHook() {
+  let useState;
+  let useEffect;
+  try {
+    const React = require("react");
+    useState = React.useState;
+    useEffect = React.useEffect;
+  } catch {
+    throw new Error("React not found. Install react to use wallet hooks.");
+  }
+  return function useWallet() {
+    const [wallet, setWallet] = useState(null);
+    const [connecting, setConnecting] = useState(false);
+    const [error, setError] = useState(null);
+    const connect = async (config) => {
+      setConnecting(true);
+      setError(null);
+      try {
+        const connected = await WalletConnector.detectAndConnect(config);
+        setWallet(connected);
+      } catch (err) {
+        setError(err);
+      } finally {
+        setConnecting(false);
+      }
+    };
+    const disconnect = async () => {
+      await WalletConnector.disconnect();
+      setWallet(null);
+    };
+    useEffect(() => {
+      const cleanup = WalletConnector.onAccountChange((publicKey) => {
+        if (wallet) {
+          setWallet({ ...wallet, publicKey, address: publicKey.toString() });
+        }
+      });
+      return cleanup;
+    }, [wallet]);
+    return {
+      wallet,
+      connecting,
+      error,
+      connect,
+      disconnect,
+      isConnected: wallet !== null
+    };
+  };
+}
+
+// src/helpers/polling.ts
+var TransactionPoller = class {
+  /**
+   * Wait for transaction confirmation
+   */
+  static async waitForConfirmation(signature, options = {}) {
+    const {
+      timeout = 6e4,
+      interval = 2e3,
+      maxInterval = 1e4,
+      maxAttempts = 30,
+      commitment = "confirmed",
+      rpcUrl
+    } = options;
+    const startTime = Date.now();
+    let currentInterval = interval;
+    let attempts = 0;
+    while (true) {
+      attempts++;
+      if (Date.now() - startTime > timeout) {
+        return {
+          confirmed: false,
+          signature,
+          error: `Transaction confirmation timeout after ${timeout}ms`
+        };
+      }
+      if (attempts > maxAttempts) {
+        return {
+          confirmed: false,
+          signature,
+          error: `Maximum polling attempts (${maxAttempts}) exceeded`
+        };
+      }
+      try {
+        const status = await this.checkTransactionStatus(signature, commitment, rpcUrl);
+        if (status.confirmed) {
+          return status;
+        }
+        if (status.error) {
+          return status;
+        }
+        await this.sleep(currentInterval);
+        currentInterval = Math.min(currentInterval * 1.5, maxInterval);
+      } catch (error) {
+        await this.sleep(currentInterval);
+        currentInterval = Math.min(currentInterval * 1.5, maxInterval);
+      }
+    }
+  }
+  /**
+   * Check transaction status via RPC
+   */
+  static async checkTransactionStatus(signature, commitment = "confirmed", rpcUrl) {
+    const endpoint = rpcUrl || this.getDefaultRpcUrl();
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getSignatureStatuses",
+        params: [[signature], { searchTransactionHistory: true }]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`RPC error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      return {
+        confirmed: false,
+        signature,
+        error: data.error.message || "RPC error"
+      };
+    }
+    const status = data.result?.value?.[0];
+    if (!status) {
+      return {
+        confirmed: false,
+        signature
+      };
+    }
+    const isConfirmed = this.isCommitmentReached(status, commitment);
+    return {
+      confirmed: isConfirmed,
+      signature,
+      slot: status.slot,
+      confirmations: status.confirmations,
+      error: status.err ? JSON.stringify(status.err) : void 0
+    };
+  }
+  /**
+   * Check if commitment level is reached
+   */
+  static isCommitmentReached(status, commitment) {
+    if (status.err) return false;
+    switch (commitment) {
+      case "processed":
+        return true;
+      // Any status means processed
+      case "confirmed":
+        return status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized";
+      case "finalized":
+        return status.confirmationStatus === "finalized";
+      default:
+        return false;
+    }
+  }
+  /**
+   * Get default RPC URL based on environment
+   */
+  static getDefaultRpcUrl() {
+    if (typeof window !== "undefined" && window.location) {
+      const hostname = window.location.hostname;
+      if (hostname.includes("localhost") || hostname.includes("dev")) {
+        return "https://api.devnet.solana.com";
+      }
+    }
+    return "https://api.mainnet-beta.solana.com";
+  }
+  /**
+   * Poll multiple transactions in parallel
+   */
+  static async waitForMultiple(signatures, options = {}) {
+    return await Promise.all(
+      signatures.map((sig) => this.waitForConfirmation(sig, options))
+    );
+  }
+  /**
+   * Get transaction details after confirmation
+   */
+  static async getTransactionDetails(signature, rpcUrl) {
+    const endpoint = rpcUrl || this.getDefaultRpcUrl();
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getTransaction",
+        params: [
+          signature,
+          {
+            encoding: "jsonParsed",
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+          }
+        ]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`RPC error: ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || "Failed to get transaction");
+    }
+    return data.result;
+  }
+  /**
+   * Check if transaction exists on chain
+   */
+  static async exists(signature, rpcUrl) {
+    try {
+      const status = await this.checkTransactionStatus(signature, "confirmed", rpcUrl);
+      return status.confirmed || !!status.slot;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get recent blockhash (useful for transaction building)
+   */
+  static async getRecentBlockhash(rpcUrl) {
+    const endpoint = rpcUrl || this.getDefaultRpcUrl();
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getLatestBlockhash",
+        params: [{ commitment: "finalized" }]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`RPC error: ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message);
+    }
+    return data.result.value;
+  }
+  /**
+   * Sleep utility
+   */
+  static sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var TransactionMonitor = class {
+  monitors = /* @__PURE__ */ new Map();
+  /**
+   * Start monitoring a transaction
+   */
+  monitor(signature, callbacks, options = {}) {
+    this.stopMonitoring(signature);
+    const { timeout = 6e4, interval = 2e3 } = options;
+    const startTime = Date.now();
+    const intervalId = setInterval(async () => {
+      if (Date.now() - startTime > timeout) {
+        this.stopMonitoring(signature);
+        callbacks.onTimeout?.();
+        return;
+      }
+      try {
+        const status = await TransactionPoller.waitForConfirmation(signature, {
+          ...options,
+          maxAttempts: 1
+          // Single check per interval
+        });
+        if (status.confirmed) {
+          this.stopMonitoring(signature);
+          callbacks.onConfirmed?.(status);
+        } else if (status.error) {
+          this.stopMonitoring(signature);
+          callbacks.onFailed?.(status);
+        }
+      } catch (error) {
+      }
+    }, interval);
+    this.monitors.set(signature, { interval: intervalId, callbacks });
+  }
+  /**
+   * Stop monitoring a transaction
+   */
+  stopMonitoring(signature) {
+    const monitor = this.monitors.get(signature);
+    if (monitor) {
+      clearInterval(monitor.interval);
+      this.monitors.delete(signature);
+    }
+  }
+  /**
+   * Stop all monitors
+   */
+  stopAll() {
+    for (const [signature] of this.monitors) {
+      this.stopMonitoring(signature);
+    }
+  }
+  /**
+   * Get active monitors
+   */
+  getActiveMonitors() {
+    return Array.from(this.monitors.keys());
+  }
+};
+
+// src/helpers/dev.ts
+var DevTools = class {
+  static debugEnabled = false;
+  static requestLog = [];
+  /**
+   * Enable debug mode (logs all API requests/responses)
+   */
+  static enableDebugMode() {
+    if (this.isDevelopment()) {
+      this.debugEnabled = true;
+      console.log("\u{1F527} ZendFi Debug Mode: ENABLED");
+      console.log("All API requests will be logged to console");
+    } else {
+      console.warn("Debug mode can only be enabled in development environment");
+    }
+  }
+  /**
+   * Disable debug mode
+   */
+  static disableDebugMode() {
+    this.debugEnabled = false;
+    console.log("\u{1F527} ZendFi Debug Mode: DISABLED");
+  }
+  /**
+   * Check if debug mode is enabled
+   */
+  static isDebugEnabled() {
+    return this.debugEnabled;
+  }
+  /**
+   * Log API request
+   */
+  static logRequest(method, url, body) {
+    if (!this.debugEnabled) return;
+    const timestamp = /* @__PURE__ */ new Date();
+    console.group(`\u{1F4E4} API Request: ${method} ${url}`);
+    console.log("Time:", timestamp.toISOString());
+    if (body) {
+      console.log("Body:", body);
+    }
+    console.groupEnd();
+    this.requestLog.push({ timestamp, method, url });
+  }
+  /**
+   * Log API response
+   */
+  static logResponse(method, url, status, data, duration) {
+    if (!this.debugEnabled) return;
+    const emoji = status >= 200 && status < 300 ? "\u2705" : "\u274C";
+    console.group(`${emoji} API Response: ${method} ${url} [${status}]`);
+    if (duration) {
+      console.log("Duration:", `${duration}ms`);
+    }
+    console.log("Data:", data);
+    console.groupEnd();
+    const lastRequest = this.requestLog[this.requestLog.length - 1];
+    if (lastRequest && lastRequest.method === method && lastRequest.url === url) {
+      lastRequest.status = status;
+      lastRequest.duration = duration;
+    }
+  }
+  /**
+   * Get request log
+   */
+  static getRequestLog() {
+    return [...this.requestLog];
+  }
+  /**
+   * Clear request log
+   */
+  static clearRequestLog() {
+    this.requestLog = [];
+    console.log("\u{1F5D1}\uFE0F Request log cleared");
+  }
+  /**
+   * Create a test session key (devnet only)
+   */
+  static async createTestSessionKey() {
+    if (!this.isDevelopment()) {
+      throw new Error("Test session keys can only be created in development");
+    }
+    const { Keypair } = await this.getSolanaWeb3();
+    const keypair = Keypair.generate();
+    return {
+      sessionKeyId: this.generateTestId("sk_test"),
+      sessionWallet: keypair.publicKey.toString(),
+      privateKey: keypair.secretKey,
+      budget: 10
+      // $10 test budget
+    };
+  }
+  /**
+   * Create a mock wallet for testing
+   */
+  static mockWallet(address) {
+    const mockAddress = address || this.generateTestAddress();
+    return {
+      address: mockAddress,
+      publicKey: { toString: () => mockAddress },
+      signTransaction: async (tx) => {
+        console.log("\u{1F527} Mock wallet: Signing transaction");
+        return tx;
+      },
+      signMessage: async (_msg) => {
+        console.log("\u{1F527} Mock wallet: Signing message");
+        return {
+          signature: new Uint8Array(64)
+          // Mock signature
+        };
+      },
+      isConnected: () => true,
+      disconnect: async () => {
+        console.log("\u{1F527} Mock wallet: Disconnected");
+      }
+    };
+  }
+  /**
+   * Log transaction flow (visual diagram in console)
+   */
+  static logTransactionFlow(paymentId) {
+    console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                    TRANSACTION FLOW                            \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551                                                                \u2551
+\u2551  Payment ID: ${paymentId}                                      \u2551
+\u2551                                                                \u2551
+\u2551  1. \u{1F3D7}\uFE0F  Create Payment Intent                                 \u2551
+\u2551      \u2514\u2500> POST /api/v1/ai/smart-payment                        \u2551
+\u2551                                                                \u2551
+\u2551  2. \u{1F510} Sign Transaction (Device-Bound)                        \u2551
+\u2551      \u2514\u2500> Client-side signing with cached keypair             \u2551
+\u2551                                                                \u2551
+\u2551  3. \u{1F4E4} Submit Signed Transaction                              \u2551
+\u2551      \u2514\u2500> POST /api/v1/ai/payments/{id}/submit-signed         \u2551
+\u2551                                                                \u2551
+\u2551  4. \u23F3 Wait for Blockchain Confirmation                       \u2551
+\u2551      \u2514\u2500> Poll Solana RPC (~30-60 seconds)                    \u2551
+\u2551                                                                \u2551
+\u2551  5. \u2705 Payment Confirmed                                      \u2551
+\u2551      \u2514\u2500> Webhook fired: payment.confirmed                    \u2551
+\u2551                                                                \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+    `);
+  }
+  /**
+   * Log session key lifecycle
+   */
+  static logSessionKeyLifecycle(sessionKeyId) {
+    console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                  SESSION KEY LIFECYCLE                        \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551                                                               \u2551
+\u2551  Session Key ID: ${sessionKeyId}                              \u2551
+\u2551                                                               \u2551
+\u2551  Phase 1: CREATION                                            \u2551
+\u2551  \u251C\u2500 Generate keypair (client-side)                            \u2551
+\u2551  \u251C\u2500 Encrypt with PIN + device fingerprint                     \u2551
+\u2551  \u251C\u2500 Send encrypted blob to backend                            \u2551
+\u2551  \u2514\u2500 Session key record created                                \u2551
+\u2551                                                               \u2551
+\u2551  Phase 2: FUNDING                                             \u2551
+\u2551  \u251C\u2500 Create top-up transaction                                 \u2551
+\u2551  \u251C\u2500 User signs with main wallet                               \u2551
+\u2551  \u251C\u2500 Submit to Solana                                          \u2551
+\u2551  \u2514\u2500 Session wallet funded                                     \u2551
+\u2551                                                               \u2551
+\u2551  Phase 3: USAGE                                               \u2551
+\u2551  \u251C\u2500 Decrypt keypair with PIN                                  \u2551
+\u2551  \u251C\u2500 Cache for 30min/1hr/24hr                                  \u2551
+\u2551  \u251C\u2500 Sign payments automatically                               \u2551
+\u2551  \u2514\u2500 Track spending against limit                              \u2551
+\u2551                                                               \u2551
+\u2551  Phase 4: REVOCATION                                          \u2551
+\u2551  \u251C\u2500 Mark as inactive in DB                                    \u2551
+\u2551  \u251C\u2500 Clear local cache                                         \u2551
+\u2551  \u2514\u2500 Remaining funds locked                                    \u2551
+\u2551                                                               \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+    `);
+  }
+  /**
+   * Benchmark API request
+   */
+  static async benchmarkRequest(name, fn) {
+    const start = performance.now();
+    const result = await fn();
+    const duration = performance.now() - start;
+    console.log(`\u23F1\uFE0F Benchmark [${name}]: ${duration.toFixed(2)}ms`);
+    return {
+      result,
+      durationMs: duration
+    };
+  }
+  /**
+   * Stress test (send multiple concurrent requests)
+   */
+  static async stressTest(name, fn, concurrency = 10, iterations = 100) {
+    console.log(`\u{1F525} Stress Test: ${name}`);
+    console.log(`Concurrency: ${concurrency}, Iterations: ${iterations}`);
+    const durations = [];
+    let successful = 0;
+    let failed = 0;
+    for (let i = 0; i < iterations; i += concurrency) {
+      const batch = Array(Math.min(concurrency, iterations - i)).fill(null).map(() => this.benchmarkRequest(`${name}-${i}`, fn));
+      const results = await Promise.allSettled(batch);
+      results.forEach((result) => {
+        if (result.status === "fulfilled") {
+          successful++;
+          durations.push(result.value.durationMs);
+        } else {
+          failed++;
+        }
+      });
+    }
+    const stats = {
+      totalRequests: iterations,
+      successful,
+      failed,
+      avgDurationMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+      minDurationMs: Math.min(...durations),
+      maxDurationMs: Math.max(...durations)
+    };
+    console.table(stats);
+    return stats;
+  }
+  /**
+   * Inspect ZendFi SDK configuration
+   */
+  static inspectConfig(client) {
+    console.group("\u{1F50D} ZendFi SDK Configuration");
+    console.log("Base URL:", client.config?.baseURL || "Unknown");
+    console.log("API Key:", client.config?.apiKey ? `${client.config.apiKey.slice(0, 10)}...` : "Not set");
+    console.log("Mode:", client.config?.mode || "Unknown");
+    console.log("Environment:", client.config?.environment || "Unknown");
+    console.log("Timeout:", client.config?.timeout || "Default");
+    console.groupEnd();
+  }
+  /**
+   * Generate test data
+   */
+  static generateTestData() {
+    return {
+      userWallet: this.generateTestAddress(),
+      agentId: `test-agent-${Date.now()}`,
+      sessionKeyId: this.generateTestId("sk_test"),
+      paymentId: this.generateTestId("pay_test")
+    };
+  }
+  /**
+   * Check if running in development environment
+   */
+  static isDevelopment() {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+    }
+    if (typeof window !== "undefined" && window.location) {
+      return window.location.hostname === "localhost" || window.location.hostname.includes("dev") || window.location.hostname.includes("staging");
+    }
+    return false;
+  }
+  /**
+   * Generate test Solana address
+   */
+  static generateTestAddress() {
+    const chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let address = "";
+    for (let i = 0; i < 44; i++) {
+      address += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return address;
+  }
+  /**
+   * Generate test ID with prefix
+   */
+  static generateTestId(prefix) {
+    const id = Array(32).fill(null).map(() => Math.floor(Math.random() * 16).toString(16)).join("");
+    return `${prefix}_${id}`;
+  }
+  /**
+   * Get Solana Web3.js
+   */
+  static async getSolanaWeb3() {
+    try {
+      return await import("@solana/web3.js");
+    } catch {
+      throw new Error("@solana/web3.js not installed");
+    }
+  }
+};
+var PerformanceMonitor = class {
+  metrics = /* @__PURE__ */ new Map();
+  /**
+   * Record a metric
+   */
+  record(name, value) {
+    const values = this.metrics.get(name) || [];
+    values.push(value);
+    this.metrics.set(name, values);
+  }
+  /**
+   * Get statistics for a metric
+   */
+  getStats(name) {
+    const values = this.metrics.get(name);
+    if (!values || values.length === 0) return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const count = values.length;
+    return {
+      count,
+      avg: values.reduce((a, b) => a + b, 0) / count,
+      min: sorted[0],
+      max: sorted[count - 1],
+      p50: sorted[Math.floor(count * 0.5)],
+      p95: sorted[Math.floor(count * 0.95)],
+      p99: sorted[Math.floor(count * 0.99)]
+    };
+  }
+  /**
+   * Get all metrics
+   */
+  getAllStats() {
+    const stats = {};
+    for (const [name] of this.metrics) {
+      stats[name] = this.getStats(name);
+    }
+    return stats;
+  }
+  /**
+   * Print report
+   */
+  printReport() {
+    console.table(this.getAllStats());
+  }
+  /**
+   * Clear all metrics
+   */
+  clear() {
+    this.metrics.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevTools,
+  PerformanceMonitor,
+  TransactionMonitor,
+  TransactionPoller,
+  WalletConnector,
+  createWalletHook
+});