@layerswap/wallet-starknet 1.2.0 → 1.3.0-next.0

package/dist/esm/StarknetProvider.js

@@ -15,16 +15,9 @@ import { useEffect, useState } from "react";
 import { mainnet, sepolia } from "@starknet-react/chains";
 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";
-// @ts-ignore
-import { ControllerConnector } from "starknetkit/controller";
 import useStarknetConnection, { resolveStarknetWallet } from "./useStarknetConnection";
 import { useStarknetStore } from "./starknetWalletStore";
+let getInjectedWalletById;
 class DiscoveryConnector extends Connector {
     constructor(wallet, store) {
         super();
@@ -72,11 +65,19 @@ class DiscoveryConnector extends Connector {
     }
 }
 _DiscoveryConnector_wallet = new WeakMap(), _DiscoveryConnector_store = new WeakMap();
-const StarknetProvider = ({ children, walletConnectConfigs }) => {
+const StarknetProvider = ({ children }) => {
     const [connectors, setConnectors] = useState([]);
-    const walletConnectConfig = walletConnectConfigs;
-    const WALLETCONNECT_PROJECT_ID = walletConnectConfig?.projectId;
     const resolveConnectors = async () => {
+        // @ts-ignore
+        const injectedModule = await import("starknetkit/injected");
+        // @ts-ignore
+        const webWalletModule = await import("starknetkit/webwallet");
+        // @ts-ignore
+        const controllerModule = await import("starknetkit/controller");
+        const InjectedConnector = injectedModule.InjectedConnector;
+        const WebWalletConnector = webWalletModule.WebWalletConnector;
+        const ControllerConnector = controllerModule.ControllerConnector;
+        getInjectedWalletById = InjectedConnector?.getInjectedWallet;
         const isSafari = typeof window !== "undefined"
             ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent)
             : false;
@@ -84,10 +85,8 @@ const StarknetProvider = ({ children, walletConnectConfigs }) => {
         const isIOS = navigator.userAgent.match(/iPhone|iPad|iPod/i);
         const defaultConnectors = [];
         if (!isSafari) {
-            if (!(isAndroid || isIOS)) {
-                defaultConnectors.push(new InjectedConnector({ options: { id: "argentX" } }));
-                defaultConnectors.push(new InjectedConnector({ options: { id: "keplr" } }));
-            }
+            defaultConnectors.push(new InjectedConnector({ options: { id: "argentX" } }));
+            defaultConnectors.push(new InjectedConnector({ options: { id: "keplr" } }));
             defaultConnectors.push(new InjectedConnector({ options: { id: "braavos" } }));
             defaultConnectors.push(new InjectedConnector({ options: { id: "xverse" } }));
         }
@@ -99,23 +98,20 @@ const StarknetProvider = ({ children, walletConnectConfigs }) => {
             if (discoverWallets.length)
                 defaultConnectors.push(...discoverWallets.map(w => new DiscoveryConnector(w, isAndroid ? "android" : "ios")));
         }
-        defaultConnectors.push(ArgentMobileConnector.init({
-            options: {
-                dappName: walletConnectConfig?.name || 'Layerswap',
-                projectId: WALLETCONNECT_PROJECT_ID,
-                url: walletConnectConfig?.url || 'https://www.layerswap.io/app/',
-                description: walletConnectConfig?.description || 'Move crypto across exchanges, blockchains, and wallets.',
-            }
-        }));
         defaultConnectors.push(new ControllerConnector());
         defaultConnectors.push(new WebWalletConnector());
         return defaultConnectors;
     };
     useEffect(() => {
-        (async () => {
-            const result = await resolveConnectors();
-            setConnectors(result);
-        })();
+        let cancelled = false;
+        resolveConnectors().then((result) => {
+            if (!cancelled)
+                setConnectors(result);
+        }).catch(() => {
+            if (!cancelled)
+                setConnectors([]);
+        });
+        return () => { cancelled = true; };
     }, []);
     const chains = [mainnet, sepolia];
     return (_jsxs(StarknetConfig, { chains: chains, provider: publicProvider(), connectors: connectors, children: [_jsx(StarknetWalletInitializer, {}), children] }));
@@ -136,7 +132,7 @@ const StarknetWalletInitializer = () => {
         const checkConnectorsReady = () => {
             const hasWallet = connectors.some(connector => {
                 try {
-                    const wallet = InjectedConnector.getInjectedWallet(connector.id);
+                    const wallet = getInjectedWalletById?.(connector.id);
                     return wallet !== null && wallet !== undefined;
                 }
                 catch {

package/dist/esm/constants.js

@@ -0,0 +1,4 @@
+import { KnownInternalNames } from "@layerswap/widget/internal";
+export const name = 'Starknet';
+export const id = 'starknet';
+export const starknetNames = [KnownInternalNames.Networks.StarkNetMainnet, KnownInternalNames.Networks.StarkNetSepolia, KnownInternalNames.Networks.StarkNetGoerli];

package/dist/esm/index.js

@@ -2,19 +2,18 @@ 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 { LazyGasProvider } from "@layerswap/widget/types";
+import { AppSettings, KnownInternalNames } from "@layerswap/widget/internal";
 import { StarknetAddressUtilsProvider } from "./starknetAddressUtilsProvider";
 import { StarknetNftProvider } from "./starknetNftProvider";
 import React from "react";
 import { useStarknetTransfer } from "./useStarknetTransfer";
+const isStarknetNetwork = (name) => KnownInternalNames.Networks.StarkNetMainnet.includes(name) ||
+    KnownInternalNames.Networks.StarkNetGoerli.includes(name) ||
+    KnownInternalNames.Networks.StarkNetSepolia.includes(name);
 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 }));
-    };
+    const { customHook, balanceProviders, gasProviders, addressUtilsProviders, nftProviders, transferProviders } = config;
     // Use custom hook if provided, otherwise use default
     const walletConnectionProvider = customHook || useStarknetConnection;
     // Use custom providers if provided, otherwise use defaults
@@ -22,7 +21,9 @@ export function createStarknetProvider(config = {}) {
     const finalBalanceProviders = balanceProviders !== undefined
         ? (Array.isArray(balanceProviders) ? balanceProviders : [balanceProviders])
         : defaultBalanceProviders;
-    const defaultGasProviders = [new StarknetGasProvider()];
+    const defaultGasProviders = [
+        new LazyGasProvider((n) => isStarknetNetwork(n.name), () => import("./starknetGasProvider").then(m => new m.StarknetGasProvider()))
+    ];
     const finalGasProviders = gasProviders !== undefined
         ? (Array.isArray(gasProviders) ? gasProviders : [gasProviders])
         : defaultGasProviders;
@@ -40,7 +41,7 @@ export function createStarknetProvider(config = {}) {
         : defaultTransferProviders;
     return {
         id: "starknet",
-        wrapper: WrapperComponent,
+        wrapper: StarknetProviderWrapper,
         walletConnectionProvider,
         addressUtilsProvider: finalAddressUtilsProviders,
         gasProvider: finalGasProviders,
@@ -60,7 +61,9 @@ export const StarknetProvider = {
     },
     walletConnectionProvider: useStarknetConnection,
     addressUtilsProvider: [new StarknetAddressUtilsProvider()],
-    gasProvider: [new StarknetGasProvider()],
+    gasProvider: [
+        new LazyGasProvider((n) => isStarknetNetwork(n.name), () => import("./starknetGasProvider").then(m => new m.StarknetGasProvider()))
+    ],
     balanceProvider: [new StarknetBalanceProvider()],
     nftProvider: [new StarknetNftProvider()],
     transferProvider: [useStarknetTransfer],

package/dist/esm/starknetAddressUtilsProvider.js

@@ -1,25 +1,33 @@
 import { validateAndParseAddress } from "./utils";
 import { KnownInternalNames } from "@layerswap/widget/internal";
+import { name } from "./constants";
 export class StarknetAddressUtilsProvider {
+    constructor() {
+        this.providerName = name;
+    }
     supportsNetwork(network) {
         return (KnownInternalNames.Networks.StarkNetMainnet.includes(network.name) || KnownInternalNames.Networks.StarkNetSepolia.includes(network.name))
             || (KnownInternalNames.Networks.ParadexMainnet.includes(network.name) || KnownInternalNames.Networks.ParadexTestnet.includes(network.name));
     }
-    isValidAddress(address) {
+    isValidAddress(props) {
+        const { address } = props;
         if (!address) {
             return false;
         }
         return validateAndParseAddress(address);
     }
-    addressFormat(address) {
+    addressFormat(props) {
+        const { address } = props;
+        if (!address)
+            return '';
         const removeHexPrefix = (hex) => {
             return hex?.replace("0x", "");
         };
         const addHexPrefix = (hex) => {
             return `0x${hex}`;
         };
-        const addAddressPadding = (address) => {
-            return addHexPrefix(removeHexPrefix(address)?.padStart(64, '0'));
+        const addAddressPadding = (addr) => {
+            return addHexPrefix(removeHexPrefix(addr)?.padStart(64, '0'));
         };
         return addAddressPadding(address?.toLowerCase());
     }

package/dist/esm/useStarknetConnection.js

@@ -3,18 +3,8 @@ import { KnownInternalNames, walletIconResolver } from "@layerswap/widget/intern
 import { useStarknetStore } from "./starknetWalletStore";
 import { useStarknetTransfer } from "./useStarknetTransfer";
 import { resolveStarknetWalletIcon } from "./utils";
-const starknetNames = [KnownInternalNames.Networks.StarkNetGoerli, KnownInternalNames.Networks.StarkNetMainnet, KnownInternalNames.Networks.StarkNetSepolia];
+import { name, id, starknetNames } from "./constants";
 export default function useStarknetConnection({ networks }) {
-    const commonSupportedNetworks = [
-        KnownInternalNames.Networks.StarkNetMainnet,
-        KnownInternalNames.Networks.StarkNetGoerli,
-        KnownInternalNames.Networks.StarkNetSepolia
-    ];
-    const withdrawalSupportedNetworks = [
-        ...commonSupportedNetworks
-    ];
-    const name = 'Starknet';
-    const id = 'starknet';
     const { connectors } = useConnect();
     const { disconnectAsync } = useDisconnect();
     const starknetWallets = useStarknetStore((state) => state.connectedWallets);
@@ -62,9 +52,9 @@ export default function useStarknetConnection({ networks }) {
                     network: starknetNetwork,
                     disconnectWallets: () => disconnectWallets(starknetConnector.id, result?.account),
                     address: result?.account,
-                    withdrawalSupportedNetworks,
-                    autofillSupportedNetworks: commonSupportedNetworks,
-                    asSourceSupportedNetworks: commonSupportedNetworks,
+                    withdrawalSupportedNetworks: starknetNames,
+                    autofillSupportedNetworks: starknetNames,
+                    asSourceSupportedNetworks: starknetNames,
                 });
                 addAccount(starknetConnector.id, result.account);
                 if (resolvedWallet) {
@@ -89,15 +79,17 @@ export default function useStarknetConnection({ networks }) {
             console.log(e);
         }
     };
-    const availableWalletsForConnect = connectors.map(connector => {
-        const name = (!connectorsConfigs.some(c => c.id === connector.id) || connector?.["_wallet"]) ? connector.name : `${connectorsConfigs.find(c => c.id === connector.id)?.name}`;
+    const availableConnectors = connectors.map(connector => {
+        const configuredName = connectorsConfigs.find(c => c.id === connector.id)?.name;
+        const name = configuredName ?? connector.name;
         return {
             name: name,
             id: connector.id,
             icon: resolveStarknetWalletIcon({ icon: connector.icon }),
             type: connector?.["_wallet"] ? 'injected' : 'other',
             installUrl: connectorsConfigs.find(c => c.id === connector.id)?.installLink,
-            extensionNotFound: !connector?.["_wallet"] && connectorsConfigs.find(c => c.id === connector.id)?.installLink !== undefined
+            extensionNotFound: !connector?.["_wallet"] && connectorsConfigs.find(c => c.id === connector.id)?.installLink !== undefined,
+            providerName: name
         };
     });
     const switchAccount = async (connector, address) => {
@@ -110,10 +102,10 @@ export default function useStarknetConnection({ networks }) {
         transfer,
         connectedWallets: starknetWallets,
         activeWallet,
-        withdrawalSupportedNetworks,
-        autofillSupportedNetworks: commonSupportedNetworks,
-        asSourceSupportedNetworks: commonSupportedNetworks,
-        availableWalletsForConnect,
+        withdrawalSupportedNetworks: starknetNames,
+        autofillSupportedNetworks: starknetNames,
+        asSourceSupportedNetworks: starknetNames,
+        availableConnectors,
         name,
         id,
         providerIcon: networks.find(n => starknetNames.some(name => name === n.name))?.logo,
@@ -130,9 +122,11 @@ export async function resolveStarknetWallet(props) {
         const walletAccount = new WalletAccount({ provider: rpcProvider, walletProvider: connector.wallet, address });
         const accounts = await walletAccount.requestAccounts(true);
         const account = accounts?.[0];
+        const configuredName = connectorsConfigs.find(c => c.id === connector.id)?.name;
+        const connectorName = configuredName ?? connector.name;
         const wallet = {
-            id: connector.name,
-            displayName: `${connector.name} - Starknet`,
+            id: connectorName,
+            displayName: `${connectorName} - Starknet`,
             address: account,
             addresses: [account],
             chainId: walletChain || '',
@@ -163,7 +157,7 @@ const connectorsConfigs = [
     },
     {
         id: "argentX",
-        name: 'Argent X',
+        name: 'Ready X',
         installLink: "https://chromewebstore.google.com/detail/argent-x-starknet-wallet/dlcobpjiigpikoobohmabehhmhfoodbb"
     },
     {

package/dist/esm/utils/resolveStarknetWalletIcon.js

@@ -1,3 +1,3 @@
 export const resolveStarknetWalletIcon = ({ icon }) => {
-    return typeof icon === 'string' ? icon : (icon.light.startsWith('data:') ? icon.light : `data:image/svg+xml;base64,${btoa(icon.light.replaceAll('currentColor', '#FFFFFF'))}`);
+    return typeof icon === 'string' ? icon : (icon.dark.startsWith('data:') ? icon.dark : `data:image/svg+xml;base64,${btoa(icon.dark.replaceAll('currentColor', '#FFFFFF'))}`);
 };