@layerswap/wallet-starknet 1.0.2 → 1.1.0

package/dist/esm/StarknetProvider.js

@@ -10,18 +10,19 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _DiscoveryConnector_wallet, _DiscoveryConnector_store;
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { mainnet, sepolia } from "@starknet-react/chains";
-import { Connector, ConnectorNotConnectedError, UserNotConnectedError, StarknetConfig, publicProvider } from '@starknet-react/core';
-import { AppSettings } from "@layerswap/widget/internal";
+import { Connector, ConnectorNotConnectedError, UserNotConnectedError, StarknetConfig, publicProvider, useConnect, useDisconnect } from '@starknet-react/core';
+import { KnownInternalNames, useSettingsState } from "@layerswap/widget/internal";
 //@ts-ignore
 import { ArgentMobileConnector } from "starknetkit/argentMobile";
 // @ts-ignore
 import { InjectedConnector } from "starknetkit/injected";
 // @ts-ignore
 import { WebWalletConnector } from "starknetkit/webwallet";
-const WALLETCONNECT_PROJECT_ID = AppSettings.WalletConnectConfig.projectId;
+import useStarknetConnection, { resolveStarknetWallet } from "./useStarknetConnection";
+import { useStarknetStore } from "./starknetWalletStore";
 class DiscoveryConnector extends Connector {
     constructor(wallet, store) {
         super();
@@ -69,8 +70,10 @@ class DiscoveryConnector extends Connector {
     }
 }
 _DiscoveryConnector_wallet = new WeakMap(), _DiscoveryConnector_store = new WeakMap();
-const StarknetProvider = ({ children }) => {
+const StarknetProvider = ({ children, walletConnectConfigs }) => {
     const [connectors, setConnectors] = useState([]);
+    const walletConnectConfig = walletConnectConfigs;
+    const WALLETCONNECT_PROJECT_ID = walletConnectConfig?.projectId;
     const resolveConnectors = async () => {
         const isSafari = typeof window !== "undefined"
             ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
@@ -84,6 +87,7 @@ const StarknetProvider = ({ children }) => {
                 defaultConnectors.push(new InjectedConnector({ options: { id: "keplr" } }));
             }
             defaultConnectors.push(new InjectedConnector({ options: { id: "braavos" } }));
+            defaultConnectors.push(new InjectedConnector({ options: { id: "xverse" } }));
         }
         if ((isAndroid || isIOS) && !defaultConnectors.some(c => c.id === "braavos")) {
             const starknet = (await import('get-starknet-core')).default;
@@ -95,10 +99,10 @@ const StarknetProvider = ({ children }) => {
         }
         defaultConnectors.push(ArgentMobileConnector.init({
             options: {
-                dappName: 'Layerswap',
+                dappName: walletConnectConfig?.name || 'Layerswap',
                 projectId: WALLETCONNECT_PROJECT_ID,
-                url: 'https://www.layerswap.io/app/',
-                description: 'Move crypto across exchanges, blockchains, and wallets.',
+                url: walletConnectConfig?.url || 'https://www.layerswap.io/app/',
+                description: walletConnectConfig?.description || 'Move crypto across exchanges, blockchains, and wallets.',
             }
         }));
         defaultConnectors.push(new WebWalletConnector());
@@ -111,6 +115,65 @@ const StarknetProvider = ({ children }) => {
         })();
     }, []);
     const chains = [mainnet, sepolia];
-    return (_jsx(StarknetConfig, { chains: chains, provider: publicProvider(), connectors: connectors, children: children }));
+    return (_jsxs(StarknetConfig, { chains: chains, provider: publicProvider(), connectors: connectors, children: [_jsx(StarknetWalletInitializer, {}), children] }));
 };
 export default StarknetProvider;
+const StarknetWalletInitializer = () => {
+    const { connectors } = useConnect();
+    const { disconnectAsync } = useDisconnect();
+    const { networks } = useSettingsState();
+    const starknetAccounts = useStarknetStore((state) => state.starknetAccounts) || {};
+    const addWallet = useStarknetStore((state) => state.connectWallet);
+    const removeAccount = useStarknetStore((state) => state.removeAccount);
+    const { withdrawalSupportedNetworks, autofillSupportedNetworks, asSourceSupportedNetworks } = useStarknetConnection({ networks });
+    const [connectorsReady, setConnectorsReady] = useState(false);
+    useEffect(() => {
+        if (connectors.length === 0 || connectorsReady || Object.keys(starknetAccounts).length == 0)
+            return;
+        const checkConnectorsReady = () => {
+            const hasWallet = connectors.some(connector => {
+                try {
+                    const wallet = InjectedConnector.getInjectedWallet(connector.id);
+                    return wallet !== null && wallet !== undefined;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (hasWallet) {
+                setConnectorsReady(true);
+            }
+        };
+        checkConnectorsReady();
+        const interval = setInterval(checkConnectorsReady, 500);
+        return () => clearInterval(interval);
+    }, [connectors, connectorsReady, starknetAccounts]);
+    useEffect(() => {
+        const initializeWallet = async () => {
+            const starknetNetwork = networks.find((n) => n.name === KnownInternalNames.Networks.StarkNetMainnet ||
+                n.name === KnownInternalNames.Networks.StarkNetSepolia);
+            for (const connector of connectors) {
+                const address = starknetAccounts[connector.id];
+                if (address) {
+                    const wallet = await resolveStarknetWallet({
+                        name: "Starknet",
+                        connector,
+                        network: starknetNetwork,
+                        disconnectWallets: () => disconnectAsync().then(() => removeAccount(address)),
+                        withdrawalSupportedNetworks,
+                        autofillSupportedNetworks,
+                        asSourceSupportedNetworks,
+                        address
+                    });
+                    if (wallet?.address) {
+                        addWallet(wallet);
+                    }
+                }
+            }
+        };
+        if (Object.keys(starknetAccounts).length && connectorsReady) {
+            initializeWallet();
+        }
+    }, [connectors, networks, connectorsReady]);
+    return _jsx(_Fragment, {});
+};

package/dist/esm/index.js

@@ -1,15 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import StarknetProviderWrapper from "./StarknetProvider";
 import useStarknetConnection from "./useStarknetConnection";
 import { StarknetBalanceProvider } from "./starknetBalanceProvider";
 import { StarknetGasProvider } from "./starknetGasProvider";
+import { AppSettings } from "@layerswap/widget/internal";
 import { StarknetAddressUtilsProvider } from "./starknetAddressUtilsProvider";
 import { StarknetNftProvider } from "./starknetNftProvider";
+import React from "react";
+import { useStarknetTransfer } from "./useStarknetTransfer";
+export { default as useStarknetConnection } from "./useStarknetConnection";
+export function createStarknetProvider(config = {}) {
+    const { walletConnectConfigs, customHook, balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders } = config;
+    // Create wrapper component with config bound
+    const WrapperComponent = ({ children }) => {
+        return (_jsx(StarknetProviderWrapper, { walletConnectConfigs: walletConnectConfigs, children: children }));
+    };
+    // Use custom hook if provided, otherwise use default
+    const walletConnectionProvider = customHook || useStarknetConnection;
+    // Use custom providers if provided, otherwise use defaults
+    const defaultBalanceProviders = [new StarknetBalanceProvider()];
+    const finalBalanceProviders = balanceProviders !== undefined
+        ? (Array.isArray(balanceProviders) ? balanceProviders : [balanceProviders])
+        : defaultBalanceProviders;
+    const defaultGasProviders = [new StarknetGasProvider()];
+    const finalGasProviders = gasProviders !== undefined
+        ? (Array.isArray(gasProviders) ? gasProviders : [gasProviders])
+        : defaultGasProviders;
+    const defaultAddressUtilsProviders = [new StarknetAddressUtilsProvider()];
+    const finalAddressUtilsProviders = addressUtilsProviders !== undefined
+        ? (Array.isArray(addressUtilsProviders) ? addressUtilsProviders : [addressUtilsProviders])
+        : defaultAddressUtilsProviders;
+    const defaultNftProviders = [new StarknetNftProvider()];
+    const finalNftProviders = nftProviders !== undefined
+        ? (Array.isArray(nftProviders) ? nftProviders : [nftProviders])
+        : defaultNftProviders;
+    const defaultTransferProviders = [useStarknetTransfer];
+    const finalTransferProviders = transferProviders !== undefined
+        ? (Array.isArray(transferProviders) ? transferProviders : [transferProviders])
+        : defaultTransferProviders;
+    return {
+        id: "starknet",
+        wrapper: WrapperComponent,
+        walletConnectionProvider,
+        addressUtilsProvider: finalAddressUtilsProviders,
+        gasProvider: finalGasProviders,
+        balanceProvider: finalBalanceProviders,
+        nftProvider: finalNftProviders,
+        transferProvider: finalTransferProviders,
+    };
+}
+/**
+ * @deprecated Use createStarknetProvider() instead. This export will be removed in a future version.
+ * Note: This uses default WalletConnect configuration provided to LayerswapProvider.
+ */
 export const StarknetProvider = {
     id: "starknet",
-    wrapper: StarknetProviderWrapper,
+    wrapper: ({ children }) => {
+        return (_jsx(StarknetProviderWrapper, { walletConnectConfigs: AppSettings.WalletConnectConfig, children: children }));
+    },
     walletConnectionProvider: useStarknetConnection,
-    addressUtilsProvider: new StarknetAddressUtilsProvider(),
-    balanceProvider: new StarknetBalanceProvider(),
-    gasProvider: new StarknetGasProvider(),
-    nftProvider: new StarknetNftProvider(),
+    addressUtilsProvider: [new StarknetAddressUtilsProvider()],
+    gasProvider: [new StarknetGasProvider()],
+    balanceProvider: [new StarknetBalanceProvider()],
+    nftProvider: [new StarknetNftProvider()],
+    transferProvider: [useStarknetTransfer],
 };

package/dist/esm/starknetWalletStore.js

@@ -0,0 +1,52 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+export const useStarknetStore = create()(persist((set) => ({
+    connectedWallets: [],
+    setActiveWallet: (address) => set({ activeWalletAddress: address }),
+    addAccount: (connectorId, l1Address) => set((state) => {
+        const updatedAccounts = {
+            ...state.starknetAccounts,
+            [connectorId]: l1Address,
+        };
+        const updatedState = {
+            starknetAccounts: updatedAccounts,
+        };
+        return updatedState;
+    }),
+    removeAccount: (address) => set((state) => {
+        const updatedAccounts = Object.entries(state.starknetAccounts || {}).reduce((acc, [key, value]) => {
+            if (value.toLowerCase() !== address.toLowerCase()) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        const updatedWallets = state.connectedWallets.filter((w) => w.address.toLowerCase() !== address.toLowerCase());
+        let newActiveAddress = state.activeWalletAddress;
+        if (state.activeWalletAddress?.toLowerCase() === address.toLowerCase()) {
+            newActiveAddress = updatedWallets.length > 0 ? updatedWallets[0].address : undefined;
+        }
+        return {
+            starknetAccounts: updatedAccounts,
+            connectedWallets: updatedWallets,
+            activeWalletAddress: newActiveAddress
+        };
+    }),
+    connectWallet: (wallet) => set((state) => {
+        if (state.connectedWallets.find(w => w.providerName == wallet.providerName && w.id == wallet.id && w.address == wallet.address)) {
+            return state;
+        }
+        return ({
+            connectedWallets: [
+                ...state.connectedWallets,
+                wallet
+            ]
+        });
+    })
+}), {
+    name: 'ls-starknet-accounts',
+    storage: createJSONStorage(() => localStorage),
+    partialize: (state) => ({
+        starknetAccounts: state.starknetAccounts,
+        activeWalletAddress: state.activeWalletAddress,
+    }),
+}));

package/dist/esm/useStarknetConnection.js

@@ -1,7 +1,8 @@
 import { useConnect, useDisconnect } from "@starknet-react/core";
-import { TransactionMessageType } from "@layerswap/widget/types";
-import { KnownInternalNames, useWalletStore } from "@layerswap/widget/internal";
+import { KnownInternalNames } from "@layerswap/widget/internal";
 import { resolveStarknetWalletConnectorIcon } from "./utils";
+import { useStarknetStore } from "./starknetWalletStore";
+import { useStarknetTransfer } from "./useStarknetTransfer";
 const starknetNames = [KnownInternalNames.Networks.StarkNetGoerli, KnownInternalNames.Networks.StarkNetMainnet, KnownInternalNames.Networks.StarkNetSepolia];
 export default function useStarknetConnection({ networks }) {
     const commonSupportedNetworks = [
@@ -16,72 +17,57 @@ export default function useStarknetConnection({ networks }) {
     const id = 'starknet';
     const { connectors } = useConnect();
     const { disconnectAsync } = useDisconnect();
-    const wallets = useWalletStore((state) => state.connectedWallets);
-    const addWallet = useWalletStore((state) => state.connectWallet);
-    const removeWallet = useWalletStore((state) => state.disconnectWallet);
+    const starknetWallets = useStarknetStore((state) => state.connectedWallets);
+    const addWallet = useStarknetStore((state) => state.connectWallet);
+    const removeAccount = useStarknetStore((state) => state.removeAccount);
+    const addAccount = useStarknetStore((state) => state.addAccount);
+    const activeWalletAddress = useStarknetStore((state) => state.activeWalletAddress);
+    const setActiveWallet = useStarknetStore((state) => state.setActiveWallet);
+    const activeWallet = starknetWallets.find(wallet => wallet.address === activeWalletAddress);
     const isMainnet = networks?.some(network => network.name === KnownInternalNames.Networks.StarkNetMainnet);
-    const getWallet = () => {
-        const wallet = wallets.find(wallet => wallet.providerName === name);
-        if (!wallet)
-            return;
-        return [wallet];
-    };
     const connectWallet = async ({ connector }) => {
         try {
-            const wallet = getWallet();
-            if (wallet) {
-                await disconnectWallets();
-            }
             const starknetConnector = connectors.find(c => c.id === connector.id);
             const result = await starknetConnector?.connect({});
             const walletChain = `0x${result?.chainId?.toString(16)}`;
             const wrongChanin = walletChain == '0x534e5f4d41494e' ? !isMainnet : isMainnet;
+            const starkent = networks.find(n => n.name === KnownInternalNames.Networks.StarkNetMainnet || n.name === KnownInternalNames.Networks.StarkNetSepolia);
             if (result?.account && wrongChanin) {
-                disconnectWallets();
+                disconnectWallets(connector?.name, result?.account);
                 const errorMessage = `Please switch the network in your wallet to ${isMainnet ? 'Mainnet' : 'Sepolia'} and click connect again`;
                 throw new Error(errorMessage);
             }
             if (result?.account && starknetConnector) {
-                const starkent = networks.find(n => n.name === KnownInternalNames.Networks.StarkNetMainnet || n.name === KnownInternalNames.Networks.StarkNetSepolia);
-                const { RpcProvider, WalletAccount } = await import('starknet');
-                const rpcProvider = new RpcProvider({
-                    nodeUrl: starkent?.node_url,
-                });
-                const starknetWalletAccount = await WalletAccount.connectSilent(rpcProvider, starknetConnector.wallet);
-                const wallet = {
-                    id: connector.name,
-                    displayName: `${connector.name} - Starknet`,
+                const wallet = await resolveStarknetWallet({
+                    name,
+                    connector: starknetConnector,
+                    network: starkent,
+                    disconnectWallets: () => disconnectWallets(starknetConnector.id, result?.account),
                     address: result?.account,
-                    addresses: [result?.account],
-                    chainId: walletChain,
-                    icon: resolveStarknetWalletConnectorIcon({ connector: connector.name, address: result?.account }),
-                    providerName: name,
-                    metadata: {
-                        starknetAccount: starknetWalletAccount,
-                        // wallet: account
-                    },
-                    isActive: true,
-                    disconnect: () => disconnectWallets(),
                     withdrawalSupportedNetworks,
                     autofillSupportedNetworks: commonSupportedNetworks,
                     asSourceSupportedNetworks: commonSupportedNetworks,
-                    networkIcon: networks.find(n => starknetNames.some(name => name === n.name))?.logo
-                };
-                addWallet(wallet);
-                return wallet;
+                });
+                addAccount(starknetConnector.id, result.account);
+                if (wallet) {
+                    addWallet(wallet);
+                    setActiveWallet(wallet.address);
+                    return wallet;
+                }
             }
         }
         catch (e) {
-            console.log(e);
             throw new Error(e);
         }
     };
-    const disconnectWallets = async () => {
+    const disconnectWallets = async (connectorName, address) => {
         try {
             await disconnectAsync();
-            removeWallet(name);
+            if (address)
+                removeAccount(address);
         }
         catch (e) {
+            //TODO: handle error
             console.log(e);
         }
     };
@@ -95,41 +81,16 @@ export default function useStarknetConnection({ networks }) {
             installUrl: connector?.["_wallet"] ? undefined : connectorsConfigs.find(c => c.id === connector.id)?.installLink,
         };
     });
-    const switchAccount = async (wallet, address) => {
-        // as we do not have multiple accounts management we will leave the method empty
-    };
-    const transfer = async (params, wallet) => {
-        const { callData } = params;
-        try {
-            const { transaction_hash: transferTxHash } = (await wallet?.metadata?.starknetAccount?.execute(JSON.parse(callData || "")) || {});
-            if (transferTxHash) {
-                return transferTxHash;
-            }
-        }
-        catch (error) {
-            const e = new Error();
-            e.message = error;
-            if (error === "An error occurred (USER_REFUSED_OP)" || error === "Execute failed") {
-                e.name = TransactionMessageType.TransactionRejected;
-                throw e;
-            }
-            else if (error === "failedTransfer") {
-                e.name = TransactionMessageType.TransactionFailed;
-                throw e;
-            }
-            else {
-                e.name = TransactionMessageType.UexpectedErrorMessage;
-                throw e;
-            }
-        }
+    const switchAccount = async (connector, address) => {
+        setActiveWallet(address);
     };
+    const { executeTransfer: transfer } = useStarknetTransfer();
     const provider = {
         connectWallet,
-        disconnectWallets,
         switchAccount,
         transfer,
-        connectedWallets: getWallet(),
-        activeWallet: getWallet()?.[0],
+        connectedWallets: starknetWallets,
+        activeWallet,
         withdrawalSupportedNetworks,
         autofillSupportedNetworks: commonSupportedNetworks,
         asSourceSupportedNetworks: commonSupportedNetworks,
@@ -137,9 +98,44 @@ export default function useStarknetConnection({ networks }) {
         name,
         id,
         providerIcon: networks.find(n => starknetNames.some(name => name === n.name))?.logo,
+        ready: connectors.length > 0
     };
     return provider;
 }
+export async function resolveStarknetWallet(props) {
+    const { name, connector, network, disconnectWallets, address, withdrawalSupportedNetworks, autofillSupportedNetworks, asSourceSupportedNetworks } = props;
+    try {
+        const walletChain = network?.chain_id;
+        const { RpcProvider, WalletAccount } = await import('starknet');
+        const rpcProvider = new RpcProvider({ nodeUrl: network?.node_url });
+        const walletAccount = new WalletAccount(rpcProvider, connector.wallet, address);
+        const accounts = await walletAccount.requestAccounts(true);
+        const account = accounts?.[0];
+        const wallet = {
+            id: connector.name,
+            displayName: `${connector.name} - Starknet`,
+            address: account,
+            addresses: [account],
+            chainId: walletChain || '',
+            icon: resolveStarknetWalletConnectorIcon({ connector: connector.name, address: account }),
+            providerName: name,
+            metadata: {
+                starknetAccount: walletAccount,
+            },
+            isActive: true,
+            withdrawalSupportedNetworks,
+            disconnect: () => disconnectWallets(connector.name, account),
+            networkIcon: starknetNames.includes(network?.name || '') ? network?.logo : undefined,
+            autofillSupportedNetworks,
+            asSourceSupportedNetworks
+        };
+        return wallet;
+    }
+    catch (e) {
+        console.warn(`Failed to initialize wallet for ${connector.name}:`, e);
+        return null;
+    }
+}
 const connectorsConfigs = [
     {
         id: "braavos",
@@ -155,5 +151,10 @@ const connectorsConfigs = [
         id: "keplr",
         name: 'Keplr',
         installLink: "https://chromewebstore.google.com/detail/keplr/dmkamcknogkgcdfhhbddcghachkejeap"
+    },
+    {
+        id: "xverse",
+        name: 'Xverse Wallet',
+        installLink: "https://chromewebstore.google.com/detail/xverse-bitcoin-crypto-wal/idnnbdplmphpflfnlkomgpfbpcgelopg"
     }
 ];

package/dist/esm/useStarknetTransfer.js

@@ -0,0 +1,43 @@
+import { KnownInternalNames } from "@layerswap/widget/internal";
+import { ActionMessageType } from "@layerswap/widget/types";
+const supportedNetworks = [
+    KnownInternalNames.Networks.StarkNetMainnet,
+    KnownInternalNames.Networks.StarkNetGoerli,
+    KnownInternalNames.Networks.StarkNetSepolia
+];
+export function useStarknetTransfer() {
+    return {
+        supportsNetwork(network) {
+            return supportedNetworks.includes(network.name);
+        },
+        async executeTransfer(params, wallet) {
+            const { callData } = params;
+            if (!wallet?.metadata?.starknetAccount) {
+                throw new Error("Starknet account not found in wallet metadata");
+            }
+            try {
+                const { transaction_hash } = await wallet.metadata.starknetAccount.execute(JSON.parse(callData || "")) || {};
+                if (!transaction_hash) {
+                    throw new Error("No transaction hash returned");
+                }
+                return transaction_hash;
+            }
+            catch (error) {
+                const e = new Error(error);
+                e.message = error;
+                if (error.message === "An error occurred (USER_REFUSED_OP)" || error.message === "Execute failed") {
+                    e.name = ActionMessageType.TransactionRejected;
+                    throw e;
+                }
+                else if (error === "failedTransfer") {
+                    e.name = ActionMessageType.TransactionFailed;
+                    throw e;
+                }
+                else {
+                    e.name = ActionMessageType.UnexpectedErrorMessage;
+                    throw e;
+                }
+            }
+        }
+    };
+}

package/dist/esm/utils/KnownStarknetConnectors.js

@@ -1,4 +1,4 @@
-import { ArgentXIcon, ArgentIcon, BraavosIcon, KeplrIcon } from "@layerswap/widget/internal";
+import { ArgentXIcon, ArgentIcon, BraavosIcon, KeplrIcon, XverseIcon } from "@layerswap/widget/internal";
 const KnownStarknetConnectors = [
     {
         id: 'ready wallet (formerly argent)',
@@ -19,6 +19,10 @@ const KnownStarknetConnectors = [
     {
         id: 'keplr',
         icon: KeplrIcon
+    },
+    {
+        id: 'xverse wallet',
+        icon: XverseIcon
     }
 ];
 export default KnownStarknetConnectors;