stellar-wallet-kit 2.0.0 → 2.0.2

package/dist/index.mjs

@@ -6,6 +6,7 @@ import { isConnected, isAllowed, setAllowed, getUserInfo, getNetwork, signTransa
 // src/types/index.ts
 var WalletType = /* @__PURE__ */ ((WalletType2) => {
   WalletType2["FREIGHTER"] = "freighter";
+  WalletType2["ALBEDO"] = "albedo";
   return WalletType2;
 })(WalletType || {});
 var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
@@ -171,7 +172,131 @@ function groupBalancesByType(balances) {
   }, {});
 }
 
+// src/utils/albedoCallback.ts
+function openAlbedoPopup(url) {
+  const popup = window.open(
+    url,
+    "albedo",
+    "width=420,height=720,resizable=yes,scrollbars=yes"
+  );
+  if (!popup) {
+    throw new Error("Failed to open Albedo popup (blocked by browser)");
+  }
+  return popup;
+}
+function waitForAlbedoResult() {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Albedo response timeout"));
+    }, 2 * 60 * 1e3);
+    const parseResult = () => {
+      const params = new URLSearchParams(window.location.search);
+      if (!params.has("pubkey") && !params.has("signed_envelope_xdr") && !params.has("signed_xdr")) {
+        return;
+      }
+      clearTimeout(timeout);
+      const result = {};
+      params.forEach((value, key) => {
+        result[key] = value;
+      });
+      window.history.replaceState({}, document.title, window.location.pathname);
+      resolve(result);
+    };
+    parseResult();
+    window.addEventListener("popstate", parseResult);
+  });
+}
+function waitForAlbedoPopup() {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Albedo response timeout"));
+    }, 2 * 60 * 1e3);
+    function handler(event) {
+      if (event.origin !== window.location.origin || event.data?.type !== "ALBEDO_RESULT") {
+        return;
+      }
+      clearTimeout(timeout);
+      window.removeEventListener("message", handler);
+      resolve(event.data.payload);
+    }
+    window.addEventListener("message", handler);
+  });
+}
+
+// src/adapters/AlbedoAdapter.ts
+var AlbedoAdapter = class {
+  constructor() {
+    this.type = "albedo" /* ALBEDO */;
+  }
+  async isAvailable() {
+    return typeof window !== "undefined";
+  }
+  async connect() {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "public-key");
+    url.searchParams.set("app_name", "Stellar Wallet Kit");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set(
+      "callback",
+      `${window.location.origin}/albedo-callback`
+    );
+    url.searchParams.set("origin", window.location.origin);
+    openAlbedoPopup(url.toString());
+    const result = await waitForAlbedoPopup();
+    if (!result.pubkey) {
+      throw new Error("Albedo connection rejected");
+    }
+    return {
+      address: result.pubkey,
+      publicKey: result.pubkey
+    };
+  }
+  async disconnect() {
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async getNetwork() {
+    throw new Error("Albedo does not expose network");
+  }
+  async signTransaction(xdr, _options) {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "tx");
+    url.searchParams.set("xdr", xdr);
+    url.searchParams.set("app_name", "Stellar Wallet Kit");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set("callback", window.location.href);
+    url.searchParams.set("origin", window.location.origin);
+    window.location.href = url.toString();
+    const result = await waitForAlbedoResult();
+    if (!result.signed_envelope_xdr) {
+      throw new Error("Albedo signing rejected");
+    }
+    return { signedTxXdr: result.signed_envelope_xdr };
+  }
+  async signAuthEntry(entryXdr, _options) {
+    const url = new URL("https://albedo.link");
+    url.searchParams.set("intent", "sign-auth-entry");
+    url.searchParams.set("xdr", entryXdr);
+    url.searchParams.set("app_name", "Stellar Wallet Kit");
+    url.searchParams.set("network", "testnet");
+    url.searchParams.set("callback", window.location.href);
+    url.searchParams.set("origin", window.location.origin);
+    window.location.href = url.toString();
+    const result = await waitForAlbedoResult();
+    if (!result.signed_xdr) {
+      throw new Error("Albedo auth entry rejected");
+    }
+    return { signedAuthEntry: result.signed_xdr };
+  }
+};
+
 // src/context/WalletContext.tsx
+var DEFAULT_SUPPORTS = {
+  silentReconnect: false,
+  networkDetection: false,
+  authEntrySigning: false
+};
 var WalletContext = createContext(void 0);
 var STORAGE_KEY = "stellar_wallet_kit";
 var getStorageData = () => {
@@ -196,7 +321,8 @@ var setStorageData = (data) => {
 };
 var isBrowser = typeof window !== "undefined";
 var walletAdapters = {
-  ["freighter" /* FREIGHTER */]: new FreighterAdapter()
+  ["freighter" /* FREIGHTER */]: new FreighterAdapter(),
+  ["albedo" /* ALBEDO */]: new AlbedoAdapter()
 };
 var walletMetadata = {
   ["freighter" /* FREIGHTER */]: {
@@ -204,14 +330,34 @@ var walletMetadata = {
     name: "Freighter",
     icon: "https://stellar.creit.tech/wallet-icons/freighter.svg",
     description: "Freighter browser extension wallet",
-    downloadUrl: "https://chrome.google.com/webstore/detail/freighter/bcacfldlkkdogcmkkibnjlakofdplcbk"
+    downloadUrl: "https://chrome.google.com/webstore/detail/freighter/bcacfldlkkdogcmkkibnjlakofdplcbk",
+    kind: "extension",
+    capabilities: {
+      silentReconnect: true,
+      networkDetection: true,
+      authEntrySigning: true
+    }
+  },
+  ["albedo" /* ALBEDO */]: {
+    id: "albedo" /* ALBEDO */,
+    name: "Albedo",
+    icon: "https://stellar.creit.tech/wallet-icons/albedo.svg",
+    description: "Web-based Stellar wallet",
+    kind: "web",
+    capabilities: {
+      silentReconnect: false,
+      networkDetection: false,
+      authEntrySigning: true
+    }
   }
 };
 function WalletProvider({ config = {}, children }) {
   const [account, setAccount] = useState(null);
   const [isConnecting, setIsConnecting] = useState(false);
   const [error, setError] = useState(null);
-  const [network, setNetwork] = useState(config.network || "TESTNET" /* TESTNET */);
+  const [network, setNetwork] = useState(
+    config.network || "TESTNET" /* TESTNET */
+  );
   const [selectedWallet, setSelectedWallet] = useState(null);
   const [availableWallets, setAvailableWallets] = useState([]);
   const [isLoadingBalances, setIsLoadingBalances] = useState(false);
@@ -221,9 +367,14 @@ function WalletProvider({ config = {}, children }) {
     const checkWallets = async () => {
       const wallets = [];
       for (const [type, adapter] of Object.entries(walletAdapters)) {
-        const installed = await adapter.isAvailable();
+        const walletType = type;
+        const meta = walletMetadata[walletType];
+        let installed = true;
+        if (meta.kind === "extension") {
+          installed = await adapter.isAvailable();
+        }
         wallets.push({
-          ...walletMetadata[type],
+          ...meta,
           installed
         });
       }
@@ -259,42 +410,54 @@ function WalletProvider({ config = {}, children }) {
       setIsLoadingBalances(false);
     }
   }, [account?.publicKey, network]);
-  const connect = useCallback(async (walletType) => {
-    setIsConnecting(true);
-    setError(null);
-    try {
-      const typeToConnect = walletType || config.defaultWallet || "freighter" /* FREIGHTER */;
-      const adapter = walletAdapters[typeToConnect];
-      if (!adapter) {
-        throw new Error(`Wallet adapter not found for ${typeToConnect}`);
-      }
-      const available = await adapter.isAvailable();
-      if (!available) {
-        throw new Error(`${walletMetadata[typeToConnect].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 });
+  const connect = useCallback(
+    async (walletType) => {
+      setIsConnecting(true);
+      setError(null);
       try {
-        const balances = await fetchAccountBalances(response.publicKey, network);
-        setAccount((prev) => prev ? { ...prev, balances } : null);
-      } catch (balanceError) {
-        console.error("Failed to fetch initial balances:", balanceError);
+        const typeToConnect = walletType || config.defaultWallet || "freighter" /* FREIGHTER */;
+        const adapter = walletAdapters[typeToConnect];
+        if (!adapter) {
+          throw new Error(`Wallet adapter not found for ${typeToConnect}`);
+        }
+        const meta = walletMetadata[typeToConnect];
+        if (meta.kind === "extension") {
+          const available = await adapter.isAvailable();
+          if (!available) {
+            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;
+      } finally {
+        setIsConnecting(false);
       }
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error("Failed to connect wallet");
-      setError(error2);
-      throw error2;
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [config.defaultWallet]);
+    },
+    [config.defaultWallet]
+  );
   const disconnect = useCallback(async () => {
     try {
       if (selectedWallet) {
@@ -311,26 +474,35 @@ function WalletProvider({ config = {}, children }) {
       throw error2;
     }
   }, [selectedWallet]);
-  const signTransaction2 = useCallback(async (xdr, options) => {
-    if (!selectedWallet) {
-      throw new Error("No wallet connected");
-    }
-    const adapter = walletAdapters[selectedWallet];
-    return adapter.signTransaction(xdr, options);
-  }, [selectedWallet]);
-  const signAuthEntry2 = useCallback(async (entryXdr, options) => {
-    if (!selectedWallet) {
-      throw new Error("No wallet connected");
-    }
-    const adapter = walletAdapters[selectedWallet];
-    return adapter.signAuthEntry(entryXdr, options);
-  }, [selectedWallet]);
-  const switchNetwork = useCallback(async (newNetwork) => {
-    setNetwork(newNetwork);
-    if (account?.publicKey) {
-      await refreshBalances();
-    }
-  }, [account?.publicKey, refreshBalances]);
+  const signTransaction2 = useCallback(
+    async (xdr, options) => {
+      if (!selectedWallet) {
+        throw new Error("No wallet connected");
+      }
+      const adapter = walletAdapters[selectedWallet];
+      return adapter.signTransaction(xdr, options);
+    },
+    [selectedWallet]
+  );
+  const signAuthEntry2 = useCallback(
+    async (entryXdr, options) => {
+      if (!selectedWallet) {
+        throw new Error("No wallet connected");
+      }
+      const adapter = walletAdapters[selectedWallet];
+      return adapter.signAuthEntry(entryXdr, options);
+    },
+    [selectedWallet]
+  );
+  const switchNetwork = useCallback(
+    async (newNetwork) => {
+      setNetwork(newNetwork);
+      if (account?.publicKey) {
+        await refreshBalances();
+      }
+    },
+    [account?.publicKey, refreshBalances]
+  );
   useEffect(() => {
     if (!account?.publicKey || !isBrowser) return;
     refreshBalances();
@@ -339,6 +511,17 @@ function WalletProvider({ config = {}, children }) {
     }, 3e4);
     return () => clearInterval(interval);
   }, [account?.publicKey, refreshBalances]);
+  const supports = useMemo(() => {
+    if (!selectedWallet) {
+      return DEFAULT_SUPPORTS;
+    }
+    const meta = walletMetadata[selectedWallet];
+    return {
+      silentReconnect: !!meta.capabilities?.silentReconnect,
+      networkDetection: !!meta.capabilities?.networkDetection,
+      authEntrySigning: !!meta.capabilities?.authEntrySigning
+    };
+  }, [selectedWallet]);
   const value = useMemo(
     () => ({
       account,
@@ -354,7 +537,8 @@ function WalletProvider({ config = {}, children }) {
       switchNetwork,
       availableWallets,
       refreshBalances,
-      isLoadingBalances
+      isLoadingBalances,
+      supports
     }),
     [
       account,
@@ -370,7 +554,8 @@ function WalletProvider({ config = {}, children }) {
       switchNetwork,
       availableWallets,
       refreshBalances,
-      isLoadingBalances
+      isLoadingBalances,
+      supports
     ]
   );
   return /* @__PURE__ */ React3.createElement(WalletContext.Provider, { value }, children);