stellar-wallet-kit 2.0.3 → 2.0.5

package/dist/index.js

@@ -2,6 +2,7 @@
 
 var React3 = require('react');
 var freighterApi = require('@stellar/freighter-api');
+var appkitUniversalConnector = require('@reown/appkit-universal-connector');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -13,6 +14,8 @@ var React3__default = /*#__PURE__*/_interopDefault(React3);
 var WalletType = /* @__PURE__ */ ((WalletType2) => {
   WalletType2["FREIGHTER"] = "freighter";
   WalletType2["ALBEDO"] = "albedo";
+  WalletType2["WALLETCONNECT"] = "walletconnect";
+  WalletType2["LOBSTR"] = "lobstr";
   return WalletType2;
 })(WalletType || {});
 var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
@@ -118,66 +121,6 @@ var FreighterAdapter = class {
   }
 };
 
-// src/utils/balanceUtils.ts
-var HORIZON_URLS = {
-  PUBLIC: "https://horizon.stellar.org",
-  TESTNET: "https://horizon-testnet.stellar.org",
-  FUTURENET: "https://horizon-futurenet.stellar.org",
-  STANDALONE: "http://localhost:8000"
-};
-async function fetchAccountBalances(publicKey, network) {
-  const horizonUrl = HORIZON_URLS[network];
-  try {
-    const response = await fetch(`${horizonUrl}/accounts/${publicKey}`);
-    if (!response.ok) {
-      if (response.status === 404) {
-        throw new Error("Account not found. Make sure the account is funded.");
-      }
-      throw new Error(`Failed to fetch account: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return data.balances;
-  } catch (error) {
-    console.error("Error fetching balances:", error);
-    throw error;
-  }
-}
-function getNativeBalance(balances) {
-  const nativeBalance = balances.find((b) => b.asset_type === "native");
-  return nativeBalance?.balance || "0";
-}
-function formatBalance(balance, decimals = 7) {
-  const num = parseFloat(balance);
-  if (isNaN(num)) return "0";
-  return num.toFixed(decimals).replace(/\.?0+$/, "");
-}
-function getAssetBalance(balances, assetCode, assetIssuer) {
-  if (!assetCode) {
-    return getNativeBalance(balances);
-  }
-  const asset = balances.find(
-    (b) => b.asset_code === assetCode && (!assetIssuer || b.asset_issuer === assetIssuer)
-  );
-  return asset?.balance || "0";
-}
-function hasSufficientBalance(balances, requiredAmount, assetCode, assetIssuer) {
-  const balance = getAssetBalance(balances, assetCode, assetIssuer);
-  return parseFloat(balance) >= parseFloat(requiredAmount);
-}
-function getTotalValueXLM(balances) {
-  return getNativeBalance(balances);
-}
-function groupBalancesByType(balances) {
-  return balances.reduce((acc, balance) => {
-    const type = balance.asset_type;
-    if (!acc[type]) {
-      acc[type] = [];
-    }
-    acc[type].push(balance);
-    return acc;
-  }, {});
-}
-
 // src/utils/albedoCallback.ts
 function openAlbedoPopup(url) {
   const popup = window.open(
@@ -297,39 +240,75 @@ var AlbedoAdapter = class {
   }
 };
 
+// src/utils/balanceUtils.ts
+var HORIZON_URLS = {
+  PUBLIC: "https://horizon.stellar.org",
+  TESTNET: "https://horizon-testnet.stellar.org",
+  FUTURENET: "https://horizon-futurenet.stellar.org",
+  STANDALONE: "http://localhost:8000"
+};
+async function fetchAccountBalances(publicKey, network) {
+  const horizonUrl = HORIZON_URLS[network];
+  try {
+    const response = await fetch(`${horizonUrl}/accounts/${publicKey}`);
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error("Account not found. Make sure the account is funded.");
+      }
+      throw new Error(`Failed to fetch account: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.balances;
+  } catch (error) {
+    console.error("Error fetching balances:", error);
+    throw error;
+  }
+}
+function getNativeBalance(balances) {
+  const nativeBalance = balances.find((b) => b.asset_type === "native");
+  return nativeBalance?.balance || "0";
+}
+function formatBalance(balance, decimals = 7) {
+  const num = parseFloat(balance);
+  if (isNaN(num)) return "0";
+  return num.toFixed(decimals).replace(/\.?0+$/, "");
+}
+function getAssetBalance(balances, assetCode, assetIssuer) {
+  if (!assetCode) {
+    return getNativeBalance(balances);
+  }
+  const asset = balances.find(
+    (b) => b.asset_code === assetCode && (!assetIssuer || b.asset_issuer === assetIssuer)
+  );
+  return asset?.balance || "0";
+}
+function hasSufficientBalance(balances, requiredAmount, assetCode, assetIssuer) {
+  const balance = getAssetBalance(balances, assetCode, assetIssuer);
+  return parseFloat(balance) >= parseFloat(requiredAmount);
+}
+function getTotalValueXLM(balances) {
+  return getNativeBalance(balances);
+}
+function groupBalancesByType(balances) {
+  return balances.reduce((acc, balance) => {
+    const type = balance.asset_type;
+    if (!acc[type]) {
+      acc[type] = [];
+    }
+    acc[type].push(balance);
+    return acc;
+  }, {});
+}
+
 // src/context/WalletContext.tsx
+var STORAGE_KEY = "stellar_wallet_kit";
+var isBrowser = typeof window !== "undefined";
 var DEFAULT_SUPPORTS = {
   silentReconnect: false,
   networkDetection: false,
   authEntrySigning: false
 };
 var WalletContext = React3.createContext(void 0);
-var STORAGE_KEY = "stellar_wallet_kit";
-var getStorageData = () => {
-  if (typeof window === "undefined") {
-    return { selectedWallet: null, autoConnect: false };
-  }
-  try {
-    const data = localStorage.getItem(STORAGE_KEY);
-    return data ? JSON.parse(data) : { selectedWallet: null, autoConnect: false };
-  } catch {
-    return { selectedWallet: null, autoConnect: false };
-  }
-};
-var setStorageData = (data) => {
-  if (typeof window === "undefined") return;
-  try {
-    const existing = getStorageData();
-    localStorage.setItem(STORAGE_KEY, JSON.stringify({ ...existing, ...data }));
-  } catch (error) {
-    console.error("Failed to save to localStorage:", error);
-  }
-};
-var isBrowser = typeof window !== "undefined";
-var walletAdapters = {
-  ["freighter" /* FREIGHTER */]: new FreighterAdapter(),
-  ["albedo" /* ALBEDO */]: new AlbedoAdapter()
-};
 var walletMetadata = {
   ["freighter" /* FREIGHTER */]: {
     id: "freighter" /* FREIGHTER */,
@@ -355,11 +334,55 @@ var walletMetadata = {
       networkDetection: false,
       authEntrySigning: true
     }
+  },
+  ["walletconnect" /* WALLETCONNECT */]: {
+    id: "walletconnect" /* WALLETCONNECT */,
+    name: "WalletConnect",
+    icon: "https://walletconnect.com/walletconnect-logo.png",
+    description: "Connect mobile wallets via WalletConnect",
+    kind: "web",
+    capabilities: {
+      silentReconnect: true,
+      networkDetection: false,
+      authEntrySigning: false
+    }
+  },
+  ["lobstr" /* LOBSTR */]: {
+    id: "lobstr" /* LOBSTR */,
+    name: "LOBSTR",
+    icon: "https://lobstr.co/favicon.ico",
+    description: "LOBSTR mobile wallet",
+    kind: "web",
+    capabilities: {
+      silentReconnect: true,
+      networkDetection: false,
+      authEntrySigning: false
+    }
   }
 };
+function getStorageData() {
+  if (!isBrowser) {
+    return { selectedWallet: null, autoConnect: false };
+  }
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    return raw ? JSON.parse(raw) : { selectedWallet: null, autoConnect: false };
+  } catch {
+    return { selectedWallet: null, autoConnect: false };
+  }
+}
+function setStorageData(data) {
+  if (!isBrowser) return;
+  const existing = getStorageData();
+  localStorage.setItem(
+    STORAGE_KEY,
+    JSON.stringify({ ...existing, ...data })
+  );
+}
 function WalletProvider({ config = {}, children }) {
   const [account, setAccount] = React3.useState(null);
   const [isConnecting, setIsConnecting] = React3.useState(false);
+  const [connectingWallet, setConnectingWallet] = React3.useState(null);
   const [error, setError] = React3.useState(null);
   const [network, setNetwork] = React3.useState(
     config.network || "TESTNET" /* TESTNET */
@@ -368,164 +391,138 @@ function WalletProvider({ config = {}, children }) {
   const [availableWallets, setAvailableWallets] = React3.useState([]);
   const [isLoadingBalances, setIsLoadingBalances] = React3.useState(false);
   const isConnected2 = !!account;
+  const walletAdapters = React3.useMemo(
+    () => ({
+      ["freighter" /* FREIGHTER */]: new FreighterAdapter(),
+      ["albedo" /* ALBEDO */]: new AlbedoAdapter(),
+      ...config.adapters ?? {}
+    }),
+    [config.adapters]
+  );
   React3.useEffect(() => {
     if (!isBrowser) return;
-    const checkWallets = async () => {
+    (async () => {
       const wallets = [];
-      for (const [type, adapter] of Object.entries(walletAdapters)) {
-        const walletType = type;
+      const entries = Object.entries(walletAdapters);
+      for (const [walletType, adapter] of entries) {
+        if (!adapter) continue;
         const meta = walletMetadata[walletType];
         let installed = true;
         if (meta.kind === "extension") {
           installed = await adapter.isAvailable();
         }
-        wallets.push({
-          ...meta,
-          installed
-        });
+        wallets.push({ ...meta, installed });
       }
       setAvailableWallets(wallets);
-    };
-    checkWallets();
-  }, []);
+    })();
+  }, [walletAdapters]);
   React3.useEffect(() => {
-    if (!isBrowser) return;
-    const autoConnectWallet = async () => {
-      const storage = getStorageData();
-      if (config.autoConnect && storage.selectedWallet) {
-        try {
-          await connect(storage.selectedWallet);
-        } catch (err) {
-          console.error("Auto-connect failed:", err);
-        }
-      }
-    };
-    autoConnectWallet();
+    if (!isBrowser || !config.autoConnect) return;
+    const { selectedWallet: selectedWallet2 } = getStorageData();
+    if (selectedWallet2) {
+      connect(selectedWallet2).catch(() => {
+      });
+    }
   }, [config.autoConnect]);
   const refreshBalances = React3.useCallback(async () => {
-    if (!account?.publicKey) {
-      return;
-    }
+    if (!account?.publicKey) return;
     setIsLoadingBalances(true);
     try {
-      const balances = await fetchAccountBalances(account.publicKey, network);
+      const balances = await fetchAccountBalances(
+        account.publicKey,
+        network
+      );
       setAccount((prev) => prev ? { ...prev, balances } : null);
-    } catch (err) {
-      console.error("Failed to fetch balances:", err);
     } finally {
       setIsLoadingBalances(false);
     }
   }, [account?.publicKey, network]);
   const connect = React3.useCallback(
     async (walletType) => {
+      const type = walletType || config.defaultWallet || "freighter" /* FREIGHTER */;
       setIsConnecting(true);
+      setConnectingWallet(type);
       setError(null);
       try {
-        const typeToConnect = walletType || config.defaultWallet || "freighter" /* FREIGHTER */;
-        const adapter = walletAdapters[typeToConnect];
+        const adapter = walletAdapters[type];
         if (!adapter) {
-          throw new Error(`Wallet adapter not found for ${typeToConnect}`);
+          throw new Error(`Wallet adapter not configured: ${type}`);
         }
-        const meta = walletMetadata[typeToConnect];
+        const meta = walletMetadata[type];
         if (meta.kind === "extension") {
-          const available = await adapter.isAvailable();
-          if (!available) {
+          const ok = await adapter.isAvailable();
+          if (!ok) {
             throw new Error(`${meta.name} is not installed`);
           }
         }
-        const response = await adapter.connect();
-        const newAccount = {
-          address: response.address,
-          publicKey: response.publicKey,
-          displayName: `${response.address.slice(
-            0,
-            4
-          )}...${response.address.slice(-4)}`
-        };
-        setAccount(newAccount);
-        setSelectedWallet(typeToConnect);
-        setStorageData({ selectedWallet: typeToConnect, autoConnect: true });
-        try {
-          const balances = await fetchAccountBalances(
-            response.publicKey,
-            network
-          );
-          setAccount((prev) => prev ? { ...prev, balances } : null);
-        } catch (balanceError) {
-          console.error("Failed to fetch initial balances:", balanceError);
-        }
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Failed to connect wallet");
-        setError(error2);
-        throw error2;
+        const res = await adapter.connect();
+        setAccount({
+          address: res.address,
+          publicKey: res.publicKey,
+          displayName: `${res.address.slice(0, 4)}\u2026${res.address.slice(-4)}`
+        });
+        setSelectedWallet(type);
+        setStorageData({ selectedWallet: type, autoConnect: true });
+        await refreshBalances();
+      } catch (e) {
+        setError(e);
+        throw e;
       } finally {
         setIsConnecting(false);
+        setConnectingWallet(null);
       }
     },
-    [config.defaultWallet]
+    [config.defaultWallet, refreshBalances, walletAdapters]
   );
   const disconnect = React3.useCallback(async () => {
-    try {
-      if (selectedWallet) {
-        const adapter = walletAdapters[selectedWallet];
-        await adapter.disconnect();
-      }
-      setAccount(null);
-      setSelectedWallet(null);
-      setError(null);
-      setStorageData({ selectedWallet: null, autoConnect: false });
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error("Failed to disconnect wallet");
-      setError(error2);
-      throw error2;
+    if (selectedWallet) {
+      await walletAdapters[selectedWallet]?.disconnect();
     }
-  }, [selectedWallet]);
+    setAccount(null);
+    setSelectedWallet(null);
+    setError(null);
+    setStorageData({ selectedWallet: null, autoConnect: false });
+  }, [selectedWallet, walletAdapters]);
   const signTransaction2 = React3.useCallback(
-    async (xdr, options) => {
+    (xdr, options) => {
       if (!selectedWallet) {
         throw new Error("No wallet connected");
       }
       const adapter = walletAdapters[selectedWallet];
+      if (!adapter) {
+        throw new Error("Wallet adapter missing");
+      }
       return adapter.signTransaction(xdr, options);
     },
-    [selectedWallet]
+    [selectedWallet, walletAdapters]
   );
   const signAuthEntry2 = React3.useCallback(
-    async (entryXdr, options) => {
+    (entryXdr, options) => {
       if (!selectedWallet) {
         throw new Error("No wallet connected");
       }
       const adapter = walletAdapters[selectedWallet];
+      if (!adapter) {
+        throw new Error("Wallet adapter missing");
+      }
       return adapter.signAuthEntry(entryXdr, options);
     },
-    [selectedWallet]
+    [selectedWallet, walletAdapters]
   );
   const switchNetwork = React3.useCallback(
-    async (newNetwork) => {
-      setNetwork(newNetwork);
-      if (account?.publicKey) {
-        await refreshBalances();
-      }
+    async (n) => {
+      setNetwork(n);
+      await refreshBalances();
     },
-    [account?.publicKey, refreshBalances]
+    [refreshBalances]
   );
-  React3.useEffect(() => {
-    if (!account?.publicKey || !isBrowser) return;
-    refreshBalances();
-    const interval = setInterval(() => {
-      refreshBalances();
-    }, 3e4);
-    return () => clearInterval(interval);
-  }, [account?.publicKey, refreshBalances]);
   const supports = React3.useMemo(() => {
-    if (!selectedWallet) {
-      return DEFAULT_SUPPORTS;
-    }
-    const meta = walletMetadata[selectedWallet];
+    if (!selectedWallet) return DEFAULT_SUPPORTS;
+    const caps = walletMetadata[selectedWallet].capabilities;
     return {
-      silentReconnect: !!meta.capabilities?.silentReconnect,
-      networkDetection: !!meta.capabilities?.networkDetection,
-      authEntrySigning: !!meta.capabilities?.authEntrySigning
+      silentReconnect: caps?.silentReconnect ?? false,
+      networkDetection: caps?.networkDetection ?? false,
+      authEntrySigning: caps?.authEntrySigning ?? false
     };
   }, [selectedWallet]);
   const value = React3.useMemo(
@@ -533,6 +530,7 @@ function WalletProvider({ config = {}, children }) {
       account,
       isConnected: isConnected2,
       isConnecting,
+      connectingWallet,
       error,
       network,
       selectedWallet,
@@ -550,6 +548,7 @@ function WalletProvider({ config = {}, children }) {
       account,
       isConnected2,
       isConnecting,
+      connectingWallet,
       error,
       network,
       selectedWallet,
@@ -567,11 +566,11 @@ function WalletProvider({ config = {}, children }) {
   return /* @__PURE__ */ React3__default.default.createElement(WalletContext.Provider, { value }, children);
 }
 function useWallet() {
-  const context = React3.useContext(WalletContext);
-  if (context === void 0) {
+  const ctx = React3.useContext(WalletContext);
+  if (!ctx) {
     throw new Error("useWallet must be used within a WalletProvider");
   }
-  return context;
+  return ctx;
 }
 function WalletModal({
   isOpen,
@@ -939,13 +938,132 @@ function ConnectButton({
     "\u{1F6AA} Disconnect"
   )))));
 }
+var stellarTestnet = {
+  id: "testnet",
+  chainNamespace: "stellar",
+  caipNetworkId: "stellar:testnet",
+  name: "Stellar Testnet",
+  nativeCurrency: {
+    name: "XLM",
+    symbol: "XLM",
+    decimals: 7
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://horizon-testnet.stellar.org"]
+    }
+  }
+};
+async function getUniversalConnector(projectId) {
+  return appkitUniversalConnector.UniversalConnector.init({
+    projectId,
+    metadata: {
+      name: "Stellar Wallet Kit",
+      description: "Connect Stellar wallets",
+      url: "https://stellar.org",
+      icons: []
+    },
+    networks: [
+      {
+        namespace: "stellar",
+        chains: [stellarTestnet],
+        methods: ["stellar_signTransaction"],
+        events: []
+      }
+    ]
+  });
+}
+
+// src/adapters/WalletConnectAdapter.ts
+var WalletConnectAdapter = class {
+  constructor(projectId) {
+    this.type = "walletconnect" /* WALLETCONNECT */;
+    this.connector = null;
+    this.session = null;
+    if (!projectId) {
+      throw new Error(
+        "WalletConnectAdapter requires a WalletConnect Project ID"
+      );
+    }
+    this.projectId = projectId;
+  }
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  async getConnector() {
+    if (!this.connector) {
+      this.connector = await getUniversalConnector(this.projectId);
+    }
+    return this.connector;
+  }
+  async connect() {
+    const connector = await this.getConnector();
+    const { session } = await connector.connect();
+    this.session = session;
+    const account = session.namespaces.stellar.accounts[0];
+    const publicKey = account.split(":")[2];
+    return {
+      address: publicKey,
+      publicKey
+    };
+  }
+  async disconnect() {
+    if (this.connector) {
+      await this.connector.disconnect();
+    }
+    this.session = null;
+  }
+  async getPublicKey() {
+    if (!this.session) return null;
+    const account = this.session.namespaces.stellar.accounts[0];
+    return account.split(":")[2];
+  }
+  async getNetwork() {
+    throw new Error("Network detection not supported via WalletConnect");
+  }
+  async signTransaction(xdr, _options) {
+    if (!this.connector || !this.session) {
+      throw new Error("No active WalletConnect session");
+    }
+    const result = await this.connector.request({
+      method: "stellar_signTransaction",
+      params: { xdr }
+    });
+    return {
+      signedTxXdr: result
+    };
+  }
+  async signAuthEntry(_entryXdr, _options) {
+    throw new Error(
+      "Auth entry signing is not supported via WalletConnect"
+    );
+  }
+};
+
+// src/wallets/createWalletAdapters.ts
+function createWalletAdapters(config) {
+  return {
+    // Extension wallet
+    ["freighter" /* FREIGHTER */]: new FreighterAdapter(),
+    // Web wallet
+    ["albedo" /* ALBEDO */]: new AlbedoAdapter(),
+    // WalletConnect (mobile wallets like Lobstr)
+    ...config.walletConnectProjectId ? {
+      ["walletconnect" /* WALLETCONNECT */]: new WalletConnectAdapter(
+        config.walletConnectProjectId
+      )
+    } : {}
+  };
+}
 
 exports.ConnectButton = ConnectButton;
 exports.FreighterAdapter = FreighterAdapter;
 exports.NetworkType = NetworkType;
+exports.WalletConnectAdapter = WalletConnectAdapter;
 exports.WalletModal = WalletModal;
 exports.WalletProvider = WalletProvider;
 exports.WalletType = WalletType;
+exports.createWalletAdapters = createWalletAdapters;
 exports.fetchAccountBalances = fetchAccountBalances;
 exports.formatBalance = formatBalance;
 exports.getAssetBalance = getAssetBalance;