@diviswap/sdk 1.7.6

package/dist/react/index.js

@@ -0,0 +1,1083 @@
+'use strict';
+
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/react/provider.tsx
+var DiviswapContext = React.createContext(null);
+function DiviswapProvider({
+  children
+}) {
+  const [user, setUser] = React.useState(null);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  React.useEffect(() => {
+    checkSession();
+  }, []);
+  const checkSession = async () => {
+    try {
+      const response = await fetch("/api/diviswap?resource=session");
+      if (response.ok) {
+        const user2 = await response.json();
+        if (user2) {
+          setUser(user2);
+        }
+      }
+    } catch (error2) {
+      console.error("Session check failed:", error2);
+    }
+  };
+  const login = async (email, password) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/diviswap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "login", email, password })
+      });
+      if (!response.ok) {
+        throw new Error("Login failed");
+      }
+      const data = await response.json();
+      setUser(data.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const logout = async () => {
+    setLoading(true);
+    try {
+      await fetch("/api/diviswap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "logout" })
+      });
+      setUser(null);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const register = async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/diviswap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "register", ...data })
+      });
+      if (!response.ok) {
+        throw new Error("Registration failed");
+      }
+      const result = await response.json();
+      setUser(result.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const createTransaction = async (data) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action: "createTransaction", ...data })
+    });
+    if (!response.ok) {
+      throw new Error("Transaction creation failed");
+    }
+    return response.json();
+  };
+  const getTransactions = async (filters) => {
+    const params = new URLSearchParams({ resource: "transactions", ...filters });
+    const response = await fetch(`/api/diviswap?${params}`);
+    if (!response.ok) {
+      throw new Error("Failed to fetch transactions");
+    }
+    return response.json();
+  };
+  const createPayee = async (data) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action: "createPayee", ...data })
+    });
+    if (!response.ok) {
+      throw new Error("Payee creation failed");
+    }
+    return response.json();
+  };
+  const getPayees = async () => {
+    const response = await fetch("/api/diviswap?resource=payees");
+    if (!response.ok) {
+      throw new Error("Failed to fetch payees");
+    }
+    return response.json();
+  };
+  const deletePayee = async (id) => {
+    const response = await fetch(`/api/diviswap?resource=payee&id=${id}`, {
+      method: "DELETE"
+    });
+    if (!response.ok) {
+      throw new Error("Failed to delete payee");
+    }
+  };
+  const calculateFees = async (amount) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action: "calculateFees", amount })
+    });
+    if (!response.ok) {
+      throw new Error("Fee calculation failed");
+    }
+    return response.json();
+  };
+  const getIntegratorFees = async () => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action: "getIntegratorFees" })
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch integrator fees");
+    }
+    return response.json();
+  };
+  const value = {
+    user,
+    loading,
+    error,
+    login,
+    logout,
+    register,
+    createTransaction,
+    getTransactions,
+    createPayee,
+    getPayees,
+    deletePayee,
+    calculateFees,
+    getIntegratorFees
+  };
+  return /* @__PURE__ */ React__default.default.createElement(DiviswapContext.Provider, { value }, children);
+}
+function useDiviswap() {
+  const context = React.useContext(DiviswapContext);
+  if (!context) {
+    throw new Error("useDiviswap must be used within a DiviswapProvider");
+  }
+  return context;
+}
+var LiberExProvider = DiviswapProvider;
+var DiviswapContext2 = React.createContext(null);
+function DiviswapFarcasterProvider({
+  children,
+  tokenStorage = "memory"
+}) {
+  const [user, setUser] = React.useState(null);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [sessionToken, setSessionToken] = React.useState(null);
+  React.useEffect(() => {
+    if (tokenStorage === "localStorage" && typeof window !== "undefined") {
+      const storedToken = localStorage.getItem("diviswap_session_token");
+      if (storedToken) {
+        setSessionToken(storedToken);
+        checkSession(storedToken);
+      }
+    }
+  }, [tokenStorage]);
+  React.useEffect(() => {
+    if (tokenStorage === "localStorage" && typeof window !== "undefined") {
+      if (sessionToken) {
+        localStorage.setItem("diviswap_session_token", sessionToken);
+      } else {
+        localStorage.removeItem("diviswap_session_token");
+      }
+    }
+  }, [sessionToken, tokenStorage]);
+  const getAuthHeaders = () => {
+    const headers = { "Content-Type": "application/json" };
+    if (sessionToken) {
+      headers["Authorization"] = `Bearer ${sessionToken}`;
+    }
+    return headers;
+  };
+  const checkSession = async (token) => {
+    try {
+      const headers = token ? { "Authorization": `Bearer ${token}` } : {};
+      const response = await fetch("/api/diviswap?resource=session", { headers });
+      if (response.ok) {
+        const userData = await response.json();
+        if (userData) {
+          setUser(userData);
+        }
+      }
+    } catch (error2) {
+      console.error("Session check failed:", error2);
+    }
+  };
+  const login = async (email, password) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/diviswap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "login", email, password })
+      });
+      if (!response.ok) {
+        throw new Error("Login failed");
+      }
+      const data = await response.json();
+      const token = data.sessionToken || data.accessToken || data.access_token;
+      if (token) {
+        setSessionToken(token);
+      }
+      setUser(data.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const logout = async () => {
+    setLoading(true);
+    try {
+      await fetch("/api/diviswap", {
+        method: "POST",
+        headers: getAuthHeaders(),
+        body: JSON.stringify({ action: "logout", sessionToken })
+      });
+      setUser(null);
+      setSessionToken(null);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const register = async (data) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/diviswap", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "register", ...data })
+      });
+      if (!response.ok) {
+        throw new Error("Registration failed");
+      }
+      const result = await response.json();
+      const token = result.sessionToken || result.accessToken || result.access_token;
+      if (token) {
+        setSessionToken(token);
+      }
+      setUser(result.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const createTransaction = async (data) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify({ action: "createTransaction", sessionToken, ...data })
+    });
+    if (!response.ok) {
+      throw new Error("Transaction creation failed");
+    }
+    return response.json();
+  };
+  const getTransactions = async (filters) => {
+    const params = new URLSearchParams({
+      resource: "transactions",
+      ...sessionToken && { sessionToken },
+      ...filters
+    });
+    const response = await fetch(`/api/diviswap?${params}`, {
+      headers: sessionToken ? { "Authorization": `Bearer ${sessionToken}` } : {}
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch transactions");
+    }
+    return response.json();
+  };
+  const createPayee = async (data) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify({ action: "createPayee", sessionToken, ...data })
+    });
+    if (!response.ok) {
+      throw new Error("Payee creation failed");
+    }
+    return response.json();
+  };
+  const getPayees = async () => {
+    const params = new URLSearchParams({ resource: "payees" });
+    if (sessionToken) {
+      params.append("sessionToken", sessionToken);
+    }
+    const response = await fetch(`/api/diviswap?${params}`, {
+      headers: sessionToken ? { "Authorization": `Bearer ${sessionToken}` } : {}
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch payees");
+    }
+    return response.json();
+  };
+  const deletePayee = async (id) => {
+    const params = new URLSearchParams({
+      resource: "payee",
+      id,
+      ...sessionToken && { sessionToken }
+    });
+    const response = await fetch(`/api/diviswap?${params}`, {
+      method: "DELETE",
+      headers: sessionToken ? { "Authorization": `Bearer ${sessionToken}` } : {}
+    });
+    if (!response.ok) {
+      throw new Error("Failed to delete payee");
+    }
+  };
+  const calculateFees = async (amount) => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify({ action: "calculateFees", sessionToken, amount })
+    });
+    if (!response.ok) {
+      throw new Error("Fee calculation failed");
+    }
+    return response.json();
+  };
+  const getIntegratorFees = async () => {
+    const response = await fetch("/api/diviswap", {
+      method: "POST",
+      headers: getAuthHeaders(),
+      body: JSON.stringify({ action: "getIntegratorFees", sessionToken })
+    });
+    if (!response.ok) {
+      throw new Error("Failed to fetch integrator fees");
+    }
+    return response.json();
+  };
+  const value = {
+    user,
+    loading,
+    error,
+    sessionToken,
+    login,
+    logout,
+    register,
+    createTransaction,
+    getTransactions,
+    createPayee,
+    getPayees,
+    deletePayee,
+    calculateFees,
+    getIntegratorFees
+  };
+  return /* @__PURE__ */ React__default.default.createElement(DiviswapContext2.Provider, { value }, children);
+}
+var LiberExFarcasterProvider = DiviswapFarcasterProvider;
+function useAuth() {
+  const { user, login, logout, register, loading, error } = useDiviswap();
+  return {
+    user,
+    login,
+    logout,
+    register,
+    loading,
+    error,
+    isAuthenticated: !!user,
+    isLoading: loading
+  };
+}
+function useTransactions() {
+  const { createTransaction, getTransactions, error } = useDiviswap();
+  const [transactions, setTransactions] = React.useState([]);
+  const [loading, setLoading] = React.useState(false);
+  const fetchTransactions = React.useCallback(async (filters) => {
+    setLoading(true);
+    try {
+      const data = await getTransactions(filters);
+      setTransactions(data);
+      return data;
+    } catch (err) {
+      console.error("Failed to fetch transactions:", err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [getTransactions]);
+  const create = React.useCallback(async (data) => {
+    setLoading(true);
+    try {
+      const transaction = await createTransaction(data);
+      await fetchTransactions();
+      return transaction;
+    } catch (err) {
+      console.error("Failed to create transaction:", err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [createTransaction, fetchTransactions]);
+  return {
+    transactions,
+    loading,
+    error,
+    fetchTransactions,
+    createTransaction: create,
+    refresh: fetchTransactions
+  };
+}
+function usePayees() {
+  const { createPayee, getPayees, deletePayee, error } = useDiviswap();
+  const [payees, setPayees] = React.useState([]);
+  const [loading, setLoading] = React.useState(false);
+  const fetchPayees = React.useCallback(async () => {
+    setLoading(true);
+    try {
+      const data = await getPayees();
+      setPayees(data);
+      return data;
+    } catch (err) {
+      console.error("Failed to fetch payees:", err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [getPayees]);
+  const create = React.useCallback(async (data) => {
+    setLoading(true);
+    try {
+      const payee = await createPayee(data);
+      await fetchPayees();
+      return payee;
+    } catch (err) {
+      console.error("Failed to create payee:", err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [createPayee, fetchPayees]);
+  const remove = React.useCallback(async (id) => {
+    setLoading(true);
+    try {
+      await deletePayee(id);
+      await fetchPayees();
+    } catch (err) {
+      console.error("Failed to delete payee:", err);
+      throw err;
+    } finally {
+      setLoading(false);
+    }
+  }, [deletePayee, fetchPayees]);
+  React.useEffect(() => {
+    fetchPayees();
+  }, [fetchPayees]);
+  return {
+    payees,
+    loading,
+    error,
+    createPayee: create,
+    deletePayee: remove,
+    refresh: fetchPayees,
+    defaultPayee: payees.find((p) => p.isDefault) || null
+  };
+}
+function useKYCStatus(options) {
+  const [kycStatus, setKycStatus] = React.useState(null);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  const fetchKYCStatus = React.useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const params = new URLSearchParams({ resource: "kycStatus" });
+      if (options?.customerId) params.set("customerId", options.customerId);
+      if (options?.customerEmail) params.set("customerEmail", options.customerEmail);
+      const response = await fetch(`/api/diviswap?${params}`);
+      if (!response.ok) {
+        throw new Error("Failed to fetch KYC status");
+      }
+      const status = await response.json();
+      setKycStatus(status);
+    } catch (err) {
+      console.error("KYC status fetch error:", err);
+      setError(err.message || "Failed to fetch KYC status");
+      setKycStatus({
+        kycStatus: "NOT_STARTED",
+        kybStatus: "NOT_REQUIRED",
+        canTransact: false,
+        requiresAction: true,
+        verificationLevel: "none",
+        nextStep: "COMPLETE_KYC"
+      });
+    } finally {
+      setLoading(false);
+    }
+  }, [options?.customerId, options?.customerEmail]);
+  React.useEffect(() => {
+    fetchKYCStatus();
+  }, [fetchKYCStatus]);
+  const refetch = React.useCallback(() => {
+    fetchKYCStatus();
+  }, [fetchKYCStatus]);
+  const isKycApproved = kycStatus?.kycStatus === "APPROVED";
+  const isKycPending = kycStatus?.kycStatus === "PENDING";
+  const isKycRejected = kycStatus?.kycStatus === "REJECTED";
+  const needsKyc = !isKycApproved && kycStatus?.requiresAction && kycStatus?.nextStep === "COMPLETE_KYC";
+  return {
+    kycStatus,
+    loading,
+    error,
+    refetch,
+    // Helper flags
+    isKycApproved,
+    isKycPending,
+    isKycRejected,
+    needsKyc,
+    canTransact: kycStatus?.canTransact ?? false,
+    verificationLevel: kycStatus?.verificationLevel ?? "none"
+  };
+}
+function useDashboard(options) {
+  const [loading, setLoading] = React.useState(true);
+  const [transactions, setTransactions] = React.useState([]);
+  const [payees, setPayees] = React.useState([]);
+  const [stats, setStats] = React.useState({
+    totalVolume: 0,
+    pendingTransactions: 0,
+    completedTransactions: 0,
+    failedTransactions: 0
+  });
+  const [chartData, setChartData] = React.useState([]);
+  const loadDashboardData = React.useCallback(async () => {
+    try {
+      setLoading(true);
+      const txParams = new URLSearchParams({
+        resource: "transactions",
+        limit: "50"
+      });
+      const payeeParams = new URLSearchParams({ resource: "payees" });
+      if (options?.customerId) {
+        txParams.set("customerId", options.customerId);
+        payeeParams.set("customerId", options.customerId);
+      }
+      if (options?.customerEmail) {
+        txParams.set("customerEmail", options.customerEmail);
+        payeeParams.set("customerEmail", options.customerEmail);
+      }
+      const [txResponse, payeeResponse] = await Promise.all([
+        fetch(`/api/diviswap?${txParams}`),
+        fetch(`/api/diviswap?${payeeParams}`)
+      ]);
+      const txData = txResponse.ok ? await txResponse.json() : [];
+      const payeeData = payeeResponse.ok ? await payeeResponse.json() : [];
+      setTransactions(txData || []);
+      setPayees(payeeData || []);
+      if (txData && txData.length > 0) {
+        const finalTransactions = txData.filter(
+          (tx) => tx.tx_type === "BANK_WITHDRAWAL" || tx.tx_type === "BANK_DEPOSIT"
+        );
+        const totalVolume = finalTransactions.reduce((sum, tx) => {
+          const amount = tx.transaction_details?.amount || 0;
+          return sum + amount;
+        }, 0);
+        const pendingTransactions = finalTransactions.filter(
+          (tx) => tx.status === "INITIATED" || tx.status === "PROCESSING" || tx.status === "pending" || tx.status === "processing"
+        ).length;
+        const completedTransactions = finalTransactions.filter(
+          (tx) => tx.status === "COMPLETED" || tx.status === "completed"
+        ).length;
+        const failedTransactions = finalTransactions.filter(
+          (tx) => tx.status === "FAILED" || tx.status === "failed"
+        ).length;
+        setStats({
+          totalVolume,
+          pendingTransactions,
+          completedTransactions,
+          failedTransactions
+        });
+        const last7Days = Array.from({ length: 7 }, (_, i) => {
+          const date = /* @__PURE__ */ new Date();
+          date.setDate(date.getDate() - (6 - i));
+          return date.toISOString().split("T")[0];
+        });
+        const dailyVolumes = last7Days.map((date) => {
+          const dayTransactions = txData.filter(
+            (tx) => tx.created_at && new Date(tx.created_at).toISOString().split("T")[0] === date && (tx.tx_type === "BANK_WITHDRAWAL" || tx.tx_type === "BANK_DEPOSIT")
+          );
+          const volume = dayTransactions.reduce(
+            (sum, tx) => sum + (tx.transaction_details?.amount || 0),
+            0
+          );
+          return {
+            date: new Date(date).toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+            volume,
+            // Amount is already in dollars
+            transactions: dayTransactions.length
+          };
+        });
+        setChartData(dailyVolumes);
+      }
+    } catch (error) {
+      console.error("Error loading dashboard data:", error);
+    } finally {
+      setLoading(false);
+    }
+  }, [options?.customerId, options?.customerEmail]);
+  React.useEffect(() => {
+    loadDashboardData();
+  }, [loadDashboardData]);
+  return {
+    stats,
+    chartData,
+    transactions: transactions.slice(0, 5),
+    // Recent 5 transactions for dashboard
+    payees,
+    loading,
+    refresh: loadDashboardData
+  };
+}
+
+// src/types/addresses.ts
+var CHAIN_IDS = {
+  // Mainnets
+  ethereum: 1,
+  optimism: 10,
+  base: 8453,
+  polygon: 137,
+  arbitrum: 42161,
+  // Testnets
+  sepolia: 11155111,
+  optimism_sepolia: 11155420,
+  base_sepolia: 84532,
+  polygon_mumbai: 80001,
+  arbitrum_sepolia: 421614
+};
+
+// src/integrations/wallet.ts
+var _WalletTracker = class _WalletTracker {
+  constructor(config = {}) {
+    this.wallet = null;
+    this.diviswap = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.config = {
+      trackAccountChanges: true,
+      trackChainChanges: true,
+      setAsDefault: true,
+      ...config
+    };
+  }
+  /**
+   * Get or create the wallet tracker instance
+   */
+  static getInstance(config) {
+    if (!_WalletTracker.instance) {
+      _WalletTracker.instance = new _WalletTracker(config);
+    }
+    return _WalletTracker.instance;
+  }
+  /**
+   * Initialize wallet tracking with Diviswap SDK instance
+   */
+  init(diviswap, wallet) {
+    this.diviswap = diviswap;
+    if (wallet) {
+      this.wallet = wallet;
+    } else if (typeof window !== "undefined" && window.ethereum) {
+      this.wallet = window.ethereum;
+    }
+    if (this.wallet && this.config.trackAccountChanges) {
+      this.setupAccountChangeListener();
+    }
+    if (this.wallet && this.config.trackChainChanges) {
+      this.setupChainChangeListener();
+    }
+  }
+  /**
+   * Connect and track a wallet
+   */
+  async connect() {
+    if (!this.wallet) {
+      throw new Error("No wallet provider available");
+    }
+    if (!this.diviswap) {
+      throw new Error("Diviswap SDK not initialized. Call init() first.");
+    }
+    try {
+      const accounts = await this.wallet.request({
+        method: "eth_requestAccounts"
+      });
+      const chainId = await this.wallet.request({
+        method: "eth_chainId"
+      });
+      const numericChainId = parseInt(chainId, 16);
+      const connections = [];
+      for (const account of accounts) {
+        const connection = {
+          address: account,
+          chainId: numericChainId,
+          chainName: this.getChainName(numericChainId)
+        };
+        await this.diviswap.addresses.trackWallet(connection);
+        connections.push(connection);
+      }
+      return connections;
+    } catch (error) {
+      console.error("Failed to connect wallet:", error);
+      throw error;
+    }
+  }
+  /**
+   * Track current wallet state without requesting connection
+   */
+  async trackCurrent() {
+    if (!this.wallet) {
+      throw new Error("No wallet provider available");
+    }
+    if (!this.diviswap) {
+      throw new Error("Diviswap SDK not initialized. Call init() first.");
+    }
+    try {
+      const accounts = await this.wallet.request({
+        method: "eth_accounts"
+      });
+      if (accounts.length === 0) {
+        return [];
+      }
+      const chainId = await this.wallet.request({
+        method: "eth_chainId"
+      });
+      const numericChainId = parseInt(chainId, 16);
+      const connections = [];
+      for (const account of accounts) {
+        const connection = {
+          address: account,
+          chainId: numericChainId,
+          chainName: this.getChainName(numericChainId)
+        };
+        await this.diviswap.addresses.trackWallet(connection);
+        connections.push(connection);
+      }
+      return connections;
+    } catch (error) {
+      console.error("Failed to track current wallet state:", error);
+      throw error;
+    }
+  }
+  /**
+   * Setup listener for account changes
+   */
+  setupAccountChangeListener() {
+    if (!this.wallet?.on) return;
+    const handler = async (accounts) => {
+      if (!this.diviswap) return;
+      try {
+        const chainId = await this.wallet.request({
+          method: "eth_chainId"
+        });
+        const numericChainId = parseInt(chainId, 16);
+        for (const account of accounts) {
+          const connection = {
+            address: account,
+            chainId: numericChainId,
+            chainName: this.getChainName(numericChainId)
+          };
+          await this.diviswap.addresses.trackWallet(connection);
+        }
+      } catch (error) {
+        console.error("Failed to handle account change:", error);
+      }
+    };
+    this.wallet.on("accountsChanged", handler);
+    this.listeners.set("accountsChanged", handler);
+  }
+  /**
+   * Setup listener for chain changes
+   */
+  setupChainChangeListener() {
+    if (!this.wallet?.on) return;
+    const handler = async (chainId) => {
+      if (!this.diviswap) return;
+      try {
+        const accounts = await this.wallet.request({
+          method: "eth_accounts"
+        });
+        const numericChainId = parseInt(chainId, 16);
+        for (const account of accounts) {
+          const connection = {
+            address: account,
+            chainId: numericChainId,
+            chainName: this.getChainName(numericChainId)
+          };
+          await this.diviswap.addresses.trackWallet(connection);
+        }
+      } catch (error) {
+        console.error("Failed to handle chain change:", error);
+      }
+    };
+    this.wallet.on("chainChanged", handler);
+    this.listeners.set("chainChanged", handler);
+  }
+  /**
+   * Get chain name from chain ID
+   */
+  getChainName(chainId) {
+    const builtInChain = Object.entries(CHAIN_IDS).find(([_, id]) => id === chainId)?.[0];
+    if (builtInChain) return builtInChain;
+    return this.config.customChains?.[chainId];
+  }
+  /**
+   * Cleanup listeners
+   */
+  cleanup() {
+    if (this.wallet?.removeListener) {
+      for (const [event, handler] of this.listeners) {
+        this.wallet.removeListener(event, handler);
+      }
+    }
+    this.listeners.clear();
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+_WalletTracker.instance = null;
+var WalletTracker = _WalletTracker;
+async function connectWallet(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker.connect();
+}
+async function trackCurrentWallet(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker.trackCurrent();
+}
+function setupWalletTracking(diviswap, wallet, config) {
+  const tracker = WalletTracker.getInstance(config);
+  tracker.init(diviswap, wallet);
+  return tracker;
+}
+
+// src/react/useAddresses.ts
+function useAddresses(diviswap) {
+  const [addresses, setAddresses] = React.useState([]);
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const fetchAddresses = React.useCallback(async () => {
+    if (!diviswap) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await diviswap.addresses.list();
+      setAddresses(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch addresses"));
+    } finally {
+      setLoading(false);
+    }
+  }, [diviswap]);
+  const createAddress = React.useCallback(async (data) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    setLoading(true);
+    setError(null);
+    try {
+      const newAddress = await diviswap.addresses.create(data);
+      setAddresses((prev) => [...prev, newAddress]);
+      return newAddress;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create address");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [diviswap]);
+  const setDefaultAddress = React.useCallback(async (data) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    setLoading(true);
+    setError(null);
+    try {
+      await diviswap.addresses.setDefault(data);
+      await fetchAddresses();
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to set default address");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [diviswap, fetchAddresses]);
+  const deleteAddress = React.useCallback(async (data) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    setLoading(true);
+    setError(null);
+    try {
+      await diviswap.addresses.delete(data);
+      setAddresses((prev) => prev.filter(
+        (addr) => !(addr.chain_id === data.chain_id && addr.address.toLowerCase() === data.address.toLowerCase())
+      ));
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete address");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, [diviswap]);
+  const getByChain = React.useCallback((chainIdOrName) => {
+    if (!diviswap) return [];
+    const chainId = typeof chainIdOrName === "string" ? diviswap.addresses.getChainId(chainIdOrName) : chainIdOrName;
+    return addresses.filter((addr) => addr.chain_id === chainId);
+  }, [addresses, diviswap]);
+  const getDefault = React.useCallback((chainIdOrName) => {
+    if (!diviswap) return null;
+    const chainId = typeof chainIdOrName === "string" ? diviswap.addresses.getChainId(chainIdOrName) : chainIdOrName;
+    return addresses.find((addr) => addr.chain_id === chainId && addr.is_default) || null;
+  }, [addresses, diviswap]);
+  React.useEffect(() => {
+    if (diviswap) {
+      fetchAddresses();
+    }
+  }, [diviswap, fetchAddresses]);
+  return {
+    addresses,
+    loading,
+    error,
+    fetchAddresses,
+    createAddress,
+    setDefaultAddress,
+    deleteAddress,
+    getByChain,
+    getDefault
+  };
+}
+function useWalletConnection(diviswap, config) {
+  const [connections, setConnections] = React.useState([]);
+  const [isConnecting, setIsConnecting] = React.useState(false);
+  const [isTracking, setIsTracking] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const connect = React.useCallback(async (wallet) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    setIsConnecting(true);
+    setError(null);
+    try {
+      const result = await connectWallet(diviswap, wallet, config);
+      setConnections(result);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to connect wallet");
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsConnecting(false);
+    }
+  }, [diviswap, config]);
+  const trackCurrent = React.useCallback(async (wallet) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    setIsTracking(true);
+    setError(null);
+    try {
+      const result = await trackCurrentWallet(diviswap, wallet, config);
+      setConnections(result);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to track current wallet");
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsTracking(false);
+    }
+  }, [diviswap, config]);
+  const setupTracking = React.useCallback((wallet) => {
+    if (!diviswap) throw new Error("Diviswap instance not provided");
+    try {
+      const tracker = setupWalletTracking(diviswap, wallet, config);
+      return tracker;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to setup wallet tracking");
+      setError(error2);
+      throw error2;
+    }
+  }, [diviswap, config]);
+  return {
+    connections,
+    isConnecting,
+    isTracking,
+    error,
+    connect,
+    trackCurrent,
+    setupTracking
+  };
+}
+function useWalletAddresses(diviswap, config) {
+  const addressHook = useAddresses(diviswap);
+  const walletHook = useWalletConnection(diviswap, config);
+  const connectAndTrack = React.useCallback(async (wallet) => {
+    const connections = await walletHook.connect(wallet);
+    await addressHook.fetchAddresses();
+    return connections;
+  }, [walletHook.connect, addressHook.fetchAddresses]);
+  const trackCurrentAndRefresh = React.useCallback(async (wallet) => {
+    const connections = await walletHook.trackCurrent(wallet);
+    await addressHook.fetchAddresses();
+    return connections;
+  }, [walletHook.trackCurrent, addressHook.fetchAddresses]);
+  return {
+    // Address management
+    ...addressHook,
+    // Wallet connection
+    connections: walletHook.connections,
+    isConnecting: walletHook.isConnecting,
+    isTracking: walletHook.isTracking,
+    walletError: walletHook.error,
+    // Combined actions
+    connectAndTrack,
+    trackCurrentAndRefresh,
+    setupTracking: walletHook.setupTracking
+  };
+}
+
+exports.DiviswapFarcasterProvider = DiviswapFarcasterProvider;
+exports.DiviswapProvider = DiviswapProvider;
+exports.LiberExFarcasterProvider = LiberExFarcasterProvider;
+exports.LiberExProvider = LiberExProvider;
+exports.useAddresses = useAddresses;
+exports.useAuth = useAuth;
+exports.useDashboard = useDashboard;
+exports.useDiviswap = useDiviswap;
+exports.useKYCStatus = useKYCStatus;
+exports.useLiberEx = useDiviswap;
+exports.usePayees = usePayees;
+exports.useTransactions = useTransactions;
+exports.useWalletAddresses = useWalletAddresses;
+exports.useWalletConnection = useWalletConnection;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map