@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

package/dist/lib/virtual/core/utils.d.ts

@@ -0,0 +1,14 @@
+export type NoInfer<A extends any> = [A][A extends any ? 0 : never];
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function memo<TDeps extends ReadonlyArray<any>, TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
+    key: false | string;
+    debug?: () => boolean;
+    onChange?: (result: TResult) => void;
+    initialDeps?: TDeps;
+}): {
+    (): TResult;
+    updateDeps(newDeps: [...TDeps]): void;
+};
+export declare function notUndefined<T>(value: T | undefined, msg?: string): T;
+export declare const approxEqual: (a: number, b: number) => boolean;
+export declare const debounce: (targetWindow: Window & typeof globalThis, fn: Function, ms: number) => (this: any, ...args: Array<any>) => void;

package/dist/lib/virtual/core/utils.js

@@ -0,0 +1,59 @@
+export function memo(getDeps, fn, opts) {
+    let deps = opts.initialDeps ?? [];
+    let result;
+    function memoizedFunction() {
+        let depTime;
+        if (opts.key && opts.debug?.())
+            depTime = Date.now();
+        const newDeps = getDeps();
+        const depsChanged = newDeps.length !== deps.length ||
+            newDeps.some((dep, index) => deps[index] !== dep);
+        if (!depsChanged) {
+            return result;
+        }
+        deps = newDeps;
+        let resultTime;
+        if (opts.key && opts.debug?.())
+            resultTime = Date.now();
+        result = fn(...newDeps);
+        if (opts.key && opts.debug?.()) {
+            const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
+            const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
+            const resultFpsPercentage = resultEndTime / 16;
+            const pad = (str, num) => {
+                str = String(str);
+                while (str.length < num) {
+                    str = ' ' + str;
+                }
+                return str;
+            };
+            console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts?.key);
+        }
+        opts?.onChange?.(result);
+        return result;
+    }
+    // Attach updateDeps to the function itself
+    memoizedFunction.updateDeps = (newDeps) => {
+        deps = newDeps;
+    };
+    return memoizedFunction;
+}
+export function notUndefined(value, msg) {
+    if (value === undefined) {
+        throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ''}`);
+    }
+    else {
+        return value;
+    }
+}
+export const approxEqual = (a, b) => Math.abs(a - b) <= 1;
+export const debounce = (targetWindow, fn, ms) => {
+    let timeoutId;
+    return function (...args) {
+        targetWindow.clearTimeout(timeoutId);
+        timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
+    };
+};

package/dist/lib/virtual/index.d.ts

@@ -0,0 +1,5 @@
+import { Virtualizer } from './core';
+import type { PartialKeys, VirtualizerOptions } from './core';
+export * from '@tanstack/virtual-core';
+export declare function useVirtualizer<TScrollElement extends Element, TItemElement extends Element>(options: PartialKeys<VirtualizerOptions<TScrollElement, TItemElement>, 'observeElementRect' | 'observeElementOffset' | 'scrollToFn'>): Virtualizer<TScrollElement, TItemElement>;
+export declare function useWindowVirtualizer<TItemElement extends Element>(options: PartialKeys<VirtualizerOptions<Window, TItemElement>, 'getScrollElement' | 'observeElementRect' | 'observeElementOffset' | 'scrollToFn'>): Virtualizer<Window, TItemElement>;

package/dist/lib/virtual/index.js

@@ -0,0 +1,47 @@
+import * as React from 'react';
+import { flushSync } from 'react-dom';
+import { Virtualizer, elementScroll, observeElementOffset, observeElementRect, observeWindowOffset, observeWindowRect, windowScroll, } from './core';
+export * from '@tanstack/virtual-core';
+const useIsomorphicLayoutEffect = typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect;
+function useVirtualizerBase(options) {
+    const rerender = React.useReducer(() => ({}), {})[1];
+    const resolvedOptions = {
+        ...options,
+        onChange: (instance, sync) => {
+            if (sync) {
+                flushSync(rerender);
+            }
+            else {
+                rerender();
+            }
+            options.onChange?.(instance, sync);
+        },
+    };
+    const [instance] = React.useState(() => new Virtualizer(resolvedOptions));
+    instance.setOptions(resolvedOptions);
+    useIsomorphicLayoutEffect(() => {
+        return instance._didMount();
+    }, []);
+    useIsomorphicLayoutEffect(() => {
+        return instance._willUpdate();
+    });
+    return instance;
+}
+export function useVirtualizer(options) {
+    return useVirtualizerBase({
+        observeElementRect: observeElementRect,
+        observeElementOffset: observeElementOffset,
+        scrollToFn: elementScroll,
+        ...options,
+    });
+}
+export function useWindowVirtualizer(options) {
+    return useVirtualizerBase({
+        getScrollElement: () => (typeof document !== 'undefined' ? window : null),
+        observeElementRect: observeWindowRect,
+        observeElementOffset: observeWindowOffset,
+        scrollToFn: windowScroll,
+        initialOffset: () => (typeof document !== 'undefined' ? window.scrollY : 0),
+        ...options,
+    });
+}

package/dist/lib/wallets/bitcoin/useBitcoin.d.ts

@@ -0,0 +1,2 @@
+import { WalletProvider } from "../../../Models/WalletProvider";
+export default function useBitcoin(): WalletProvider;

package/dist/lib/wallets/bitcoin/useBitcoin.js

@@ -0,0 +1,158 @@
+import { NetworkType } from "../../../Models/Network";
+import { useSettingsState } from "../../../context/settings";
+import { useConnectModal } from "../../../components/Wallet/WalletModal";
+import { useConnect, useAccount, useConfig } from '@bigmi/react';
+import { disconnect } from "@bigmi/client";
+import { useMemo } from "react";
+import convertSvgComponentToBase64 from "../../../components/utils/convertSvgComponentToBase64";
+import { resolveWalletConnectorIcon } from "../utils/resolveWalletIcon";
+import KnownInternalNames from "../../knownIds";
+import { isValidAddress } from "../../../lib/address/validator";
+import { useBitcoinConnectors } from "../../../components/Wallet/WalletProviders/BitcoinProvider";
+const bitcoinNames = [KnownInternalNames.Networks.BitcoinMainnet, KnownInternalNames.Networks.BitcoinTestnet];
+export default function useBitcoin() {
+    const name = 'Bitcoin';
+    const id = 'bitcoin';
+    const { networks } = useSettingsState();
+    const { connectors: resolvedConnectors } = useBitcoinConnectors();
+    const commonSupportedNetworks = [
+        ...networks.filter(network => network.type === NetworkType.Bitcoin).map(l => l.name),
+    ];
+    const account = useAccount();
+    const { connectAsync, connectors } = useConnect();
+    const config = useConfig();
+    const { setSelectedConnector } = useConnectModal();
+    const switchAccount = async (wallet, address) => {
+        // as we do not have multiple accounts management we will leave the method empty
+    };
+    const disconnectWallet = async (connectorName) => {
+        try {
+            const connector = connectors.find(w => w.name.toLowerCase() === connectorName.toLowerCase());
+            await disconnect(config, { connector });
+        }
+        catch (e) {
+            console.log(e);
+        }
+    };
+    const disconnectWallets = () => {
+        try {
+            connectors.forEach(async (connector) => {
+                await disconnect(config, { connector });
+            });
+        }
+        catch (e) {
+            console.log(e);
+        }
+    };
+    const connectWallet = async ({ connector: internalConnector }) => {
+        try {
+            const connector = connectors.find(w => w.id === internalConnector.id);
+            if (!connector)
+                throw new Error("Connector not found");
+            const Icon = connector.icon;
+            const base64Icon = typeof Icon == 'string' ? Icon : convertSvgComponentToBase64(Icon);
+            setSelectedConnector({ ...internalConnector, icon: base64Icon });
+            if (account) {
+                await disconnect(config, { connector });
+            }
+            if (!connector)
+                throw new Error("Connector not found");
+            const result = await connectAsync({ connector: connector });
+            if (!result.accounts)
+                throw new Error("No result from connector");
+            const address = result.accounts[0];
+            const network = networks.find(n => commonSupportedNetworks.includes(n.name));
+            const wrongChanin = !isValidAddress(address, network);
+            if (address && wrongChanin) {
+                await disconnect(config, { connector });
+                const isMainnet = network?.name === KnownInternalNames.Networks.BitcoinMainnet;
+                const errorMessage = `Please switch the network in your wallet to ${isMainnet ? 'Mainnet' : 'Testnet'} and click connect again`;
+                throw new Error(errorMessage);
+            }
+            const wallet = resolveWallet({
+                activeConnection: { address: address, id: connector.id },
+                connector,
+                addresses: [address],
+                networks,
+                discconnect: disconnectWallet,
+                supportedNetworks: {
+                    asSource: commonSupportedNetworks,
+                    autofill: commonSupportedNetworks,
+                    withdrawal: commonSupportedNetworks
+                },
+                providerName: name
+            });
+            return wallet;
+        }
+        catch (e) {
+            const error = e;
+            if (error.name == 'ConnectorAlreadyConnectedError') {
+                throw new Error("Wallet is already connected");
+            }
+            else {
+                throw new Error(e.message || e);
+            }
+        }
+    };
+    const resolvedWallet = useMemo(() => {
+        const connector = account.connector;
+        if (!account || !connector)
+            return undefined;
+        const wallet = resolveWallet({
+            activeConnection: { address: account.address || '', id: connector.id },
+            connector,
+            addresses: account.address ? [account.address] : [],
+            networks,
+            discconnect: disconnectWallet,
+            supportedNetworks: {
+                asSource: commonSupportedNetworks,
+                autofill: commonSupportedNetworks,
+                withdrawal: commonSupportedNetworks
+            },
+            providerName: name
+        });
+        if (!wallet)
+            return undefined;
+        return wallet;
+    }, [account, connectors]);
+    const providerIcon = networks.find(n => commonSupportedNetworks.some(name => name === n.name))?.logo;
+    const provider = {
+        connectWallet,
+        disconnectWallets,
+        connectedWallets: resolvedWallet ? [resolvedWallet] : [],
+        activeWallet: resolvedWallet,
+        availableWalletsForConnect: resolvedConnectors,
+        autofillSupportedNetworks: commonSupportedNetworks,
+        withdrawalSupportedNetworks: commonSupportedNetworks,
+        asSourceSupportedNetworks: commonSupportedNetworks,
+        name,
+        id,
+        providerIcon,
+        unsupportedPlatforms: ["mobile"],
+        switchAccount
+    };
+    return provider;
+}
+const resolveWallet = (props) => {
+    const { activeConnection, connector, networks, discconnect, supportedNetworks, providerName, addresses } = props;
+    const accountIsActive = activeConnection?.id === connector?.id;
+    if (!connector)
+        return undefined;
+    const walletname = `${connector?.name} ${" - Bitcoin"}`;
+    const wallet = {
+        id: connector.name,
+        internalId: connector.id,
+        isActive: accountIsActive,
+        address: addresses[0],
+        addresses: [addresses[0]],
+        displayName: walletname,
+        providerName,
+        icon: resolveWalletConnectorIcon({ connector: connector.name, address: addresses[0], iconUrl: connector.icon }),
+        disconnect: () => discconnect(connector.name),
+        asSourceSupportedNetworks: supportedNetworks.asSource,
+        autofillSupportedNetworks: supportedNetworks.autofill,
+        withdrawalSupportedNetworks: supportedNetworks.withdrawal,
+        networkIcon: networks.find(n => bitcoinNames.some(name => name === n.name))?.logo,
+    };
+    return wallet;
+};

package/dist/lib/wallets/connectors/browserInjected/index.d.ts

@@ -13,7 +13,7 @@ export declare function browserInjected(): (config: {
         chainId?: number | undefined;
         isReconnecting?: boolean | undefined;
     } | undefined): Promise<{
-        accounts: readonly import("abitype").Address[];
+        accounts: readonly import("viem").Address[];
         chainId: number;
     }>;
     icon: undefined;
@@ -24,7 +24,7 @@ export declare function browserInjected(): (config: {
     type: string;
     setup?: (() => Promise<void>) | undefined;
     disconnect: () => Promise<void>;
-    getAccounts: () => Promise<readonly import("abitype").Address[]>;
+    getAccounts: () => Promise<readonly import("viem").Address[]>;
     getChainId: () => Promise<number>;
     getProvider: (parameters?: {
         chainId?: number | undefined;

package/dist/lib/wallets/connectors/explicitInjectedProviderDetected.d.ts

@@ -0,0 +1,30 @@
+export declare function explicitInjectedProviderDetected(): boolean;
+export type Evaluate<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+export type WalletProvider = Evaluate<EIP1193Provider & {
+    [key in WalletProviderFlags]?: true | undefined;
+} & {
+    providers?: any[] | undefined;
+    /** Only exists in MetaMask as of 2022/04/03 */
+    _events?: {
+        connect?: (() => void) | undefined;
+    } | undefined;
+    /** Only exists in MetaMask as of 2022/04/03 */
+    _state?: {
+        accounts?: string[];
+        initialized?: boolean;
+        isConnected?: boolean;
+        isPermanentlyDisconnected?: boolean;
+        isUnlocked?: boolean;
+    } | undefined;
+}>;
+export type WindowProvider = {
+    coinbaseWalletExtension?: WalletProvider | undefined;
+    ethereum?: WalletProvider | undefined;
+    phantom?: {
+        ethereum: WalletProvider;
+    } | undefined;
+    providers?: any[] | undefined;
+};
+export type WalletProviderFlags = 'isApexWallet' | 'isAvalanche' | 'isBackpack' | 'isBifrost' | 'isBitKeep' | 'isBitski' | 'isBlockWallet' | 'isBraveWallet' | 'isCoinbaseWallet' | 'isDawn' | 'isEnkrypt' | 'isExodus' | 'isFrame' | 'isFrontier' | 'isGamestop' | 'isHyperPay' | 'isImToken' | 'isKuCoinWallet' | 'isMathWallet' | 'isMetaMask' | 'isNestWallet' | 'isOkxWallet' | 'isOKExWallet' | 'isOneInchAndroidWallet' | 'isOneInchIOSWallet' | 'isOpera' | 'isPhantom' | 'isPortal' | 'isRabby' | 'isRainbow' | 'isStatus' | 'isTally' | 'isTokenPocket' | 'isTokenary' | 'isTrust' | 'isTrustWallet' | 'isXDEFI' | 'isZerion' | 'isTalisman' | 'isZeal' | 'isCoin98' | 'isMEWwallet' | 'isSafeheron' | 'isSafePal' | '__seif';

package/dist/lib/wallets/connectors/explicitInjectedProviderDetected.js

@@ -0,0 +1,6 @@
+export function explicitInjectedProviderDetected() {
+    const _window = typeof window !== 'undefined' ? window : undefined;
+    if (typeof _window === 'undefined' || typeof _window.ethereum === 'undefined')
+        return false;
+    return !!_window.ethereum;
+}

package/dist/lib/wallets/connectors/resolveConnectors/index.d.ts

@@ -0,0 +1,43 @@
+import { InternalConnector } from "../../../../Models/WalletProvider";
+export type WalletConnectWallet = {
+    id: string;
+    name: string;
+    mobile: {
+        native?: boolean;
+        universal?: boolean;
+    };
+    desktop?: {
+        native?: boolean;
+        universal?: boolean;
+    };
+    rdns?: string;
+    type: string;
+    icon: string;
+    projectId: string;
+    showQrModal: boolean;
+    customStoragePrefix: string;
+} & InternalConnector;
+export declare const resolveWallets: () => WalletConnectWallet[];
+export declare const resolveConnector: (name: string) => import("wagmi").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
+    connect(parameters?: {
+        chainId?: number | undefined;
+        isReconnecting?: boolean | undefined;
+        pairingTopic?: string | undefined;
+    }): Promise<{
+        accounts: readonly import("viem").Address[];
+        chainId: number;
+    }>;
+    getNamespaceChainsIds(): number[];
+    getRequestedChainsIds(): Promise<number[]>;
+    isChainsStale(): Promise<boolean>;
+    onConnect(connectInfo: import("viem").ProviderConnectInfo): void;
+    onDisplayUri(uri: string): void;
+    onSessionDelete(data: {
+        topic: string;
+    }): void;
+    setRequestedChainsIds(chains: number[]): void;
+    requestedChainsStorageKey: `${string}.requestedChains`;
+}, {
+    [x: `${string}.requestedChains`]: number[];
+}>;
+export declare const walletConnectWallets: WalletConnectWallet[];

package/dist/lib/wallets/connectors/resolveConnectors/index.js

@@ -0,0 +1,59 @@
+import { walletConnect } from "./walletConnect";
+import walletsData from "../../../../public/walletsData.json";
+import { resolveWalletConnectorIndex } from "../../utils/resolveWalletIcon";
+import AppSettings from "../../../../lib/AppSettings";
+const projectId = AppSettings.WalletConnectConfig.projectId;
+const wallets = Object.values(walletsData.listings);
+const walletsToFilter = [
+    "5d9f1395b3a8e848684848dc4147cbd05c8d54bb737eac78fe103901fe6b01a1"
+];
+export const resolveWallets = () => {
+    const resolvedWallets = pickLatestBy(wallets, c => c.slug).filter(w => w.mobile.native || w.mobile.universal && w.name && w.slug && !walletsToFilter.some(wtf => wtf == w.id)).map(wallet => {
+        const w = resolveWallet(wallet);
+        return w;
+    });
+    return resolvedWallets;
+};
+export const resolveConnector = (name) => {
+    const wallet = wallets.find(w => w.name === name && !walletsToFilter.includes(w.id));
+    const params = resolveWallet(wallet);
+    return walletConnect(params);
+};
+const resolveWallet = (wallet) => {
+    if (!wallet) {
+        throw new Error(`Wallet ${wallet.name} not found`);
+    }
+    const w = {
+        id: wallet.slug,
+        name: wallet.name,
+        mobile: wallet.mobile,
+        rdns: wallet.rdns ? `${wallet.rdns}.wc` : undefined,
+        icon: wallet.image_url.sm,
+        projectId,
+        showQrModal: false,
+        customStoragePrefix: wallet.slug,
+        order: resolveWalletConnectorIndex(wallet.slug),
+        type: "other",
+        isMobileSupported: wallet.mobile.universal || wallet.mobile.native
+    };
+    return w;
+};
+export const walletConnectWallets = resolveWallets();
+function pickLatestBy(connectors, keyFn) {
+    const map = new Map();
+    for (const c of connectors) {
+        const key = keyFn(c);
+        const existing = map.get(key);
+        if (!existing) {
+            map.set(key, c);
+        }
+        else {
+            const a = new Date(existing.updatedAt);
+            const b = new Date(c.updatedAt);
+            if (b > a) {
+                map.set(key, c);
+            }
+        }
+    }
+    return Array.from(map.values());
+}

package/dist/lib/wallets/connectors/{walletConnect/index.d.ts → resolveConnectors/walletConnect.d.ts}

@@ -34,10 +34,22 @@ export type WalletConnectParameters = Compute<{
      */
     isNewChainsStale?: boolean;
 } & Omit<EthereumProviderOptions, 'chains' | 'events' | 'optionalChains' | 'optionalEvents' | 'optionalMethods' | 'methods' | 'rpcMap' | 'showQrModal'> & ExactPartial<Pick<EthereumProviderOptions, 'showQrModal'>>>;
-export declare function walletConnect(parameters: WalletConnectParameters): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
+type Params = {
+    id: string;
+    name: string;
+    rdns: string;
+    type: string;
+    mobile: {
+        native: string;
+        universal: string;
+    };
+    icon: string;
+} & WalletConnectParameters;
+export declare function walletConnect(parameters: Params): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
     connect(parameters?: {
-        chainId?: number;
-        pairingTopic?: string;
+        chainId?: number | undefined;
+        isReconnecting?: boolean | undefined;
+        pairingTopic?: string | undefined;
     }): Promise<{
         accounts: readonly Address[];
         chainId: number;
@@ -56,6 +68,6 @@ export declare function walletConnect(parameters: WalletConnectParameters): impo
     [x: `${string}.requestedChains`]: number[];
 }>;
 export declare namespace walletConnect {
-    var type: "walletConnect";
+    var type: string;
 }
 export {};

package/dist/lib/wallets/connectors/{metamask/index.js → resolveConnectors/walletConnect.js}

@@ -1,15 +1,10 @@
 import { ChainNotConfiguredError, ProviderNotFoundError, createConnector, extractRpcUrls, } from '@wagmi/core';
 import { SwitchChainError, UserRejectedRequestError, getAddress, numberToHex, } from 'viem';
-import { getInjectedConnector } from '../getInjectedConnector';
-import { isAndroid, isIOS } from '../utils/isMobile';
-export function metaMask(parameters) {
-    const isMetaMaskInjected = parameters?.providers?.some((provider) => provider.info.name.toLowerCase() === 'metamask');
-    const shouldUseWalletConnect = !isMetaMaskInjected;
-    return shouldUseWalletConnect ? walletConnect(parameters) : getInjectedConnector({ flag: 'isMetaMask' })({ id: 'metaMaskSDK', name: 'My Metamask' });
-}
+import { isAndroid, isMobile, isIOS } from '../utils/isMobile';
 walletConnect.type = 'metamask';
 export function walletConnect(parameters) {
     const isNewChainsStale = parameters.isNewChainsStale ?? true;
+    const { id, name, rdns, type, mobile, icon } = parameters;
     let provider_;
     let providerPromise;
     const NAMESPACE = 'eip155';
@@ -20,19 +15,13 @@ export function walletConnect(parameters) {
     let sessionDelete;
     let disconnect;
     return createConnector((config) => ({
-        id: 'io.metamask',
-        name: 'MetaMask',
-        rdns: 'io.metamask',
-        type: walletConnect.type,
-        deepLink: 'metamask://wc',
-        resolveURI: (uri) => {
-            return isAndroid()
-                ? uri
-                : isIOS()
-                    ? // currently broken in MetaMask v6.5.0 https://github.com/MetaMask/metamask-mobile/issues/6457
-                        `metamask://wc?uri=${encodeURIComponent(uri)}`
-                    : `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}`;
-        },
+        id: id,
+        name: name,
+        rdns: rdns,
+        type: type,
+        deepLink: mobile.native || mobile.universal,
+        icon: icon,
+        resolveURI: (uri) => getResolveUri(id, uri, mobile),
         async setup() {
             const provider = await this.getProvider().catch(() => null);
             if (!provider)
@@ -365,3 +354,43 @@ export function walletConnect(parameters) {
         },
     }));
 }
+function addWC(url) {
+    if (url?.endsWith("://")) {
+        return url + "wc";
+    }
+    else if (url?.endsWith("/")) {
+        return url + "wc";
+    }
+    else {
+        return url + "/wc";
+    }
+}
+function getResolveUri(id, uri, mobile) {
+    switch (id) {
+        case 'bitkeep':
+            return isAndroid()
+                ? uri
+                : `bitkeep://wc?uri=${encodeURIComponent(uri)}`;
+        case 'metamask':
+            return isAndroid()
+                ? uri
+                : isIOS()
+                    ? // currently broken in MetaMask v6.5.0 https://github.com/MetaMask/metamask-mobile/issues/6457
+                        `metamask://wc?uri=${encodeURIComponent(uri)}`
+                    : `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}`;
+        case 'okx-wallet':
+            return isAndroid()
+                ? uri
+                : `okex://main/wc?uri=${encodeURIComponent(uri)}`;
+        case 'rainbow':
+            return isAndroid()
+                ? uri
+                : isIOS()
+                    ? `rainbow://wc?uri=${encodeURIComponent(uri)}&connector=rainbowkit`
+                    : `https://rnbwapp.com/wc?uri=${encodeURIComponent(uri)}&connector=rainbowkit`;
+        default:
+            return (isAndroid() || !isMobile())
+                ? uri
+                : `${addWC(mobile.native)}?uri=${encodeURIComponent(uri)}`;
+    }
+}

package/dist/lib/wallets/connectors/types.d.ts

@@ -0,0 +1,7 @@
+import { Connector } from "wagmi";
+export type LSConnector = Connector & {
+    resolveURI?: (uri: string) => string;
+    order?: number;
+    isAvailable?: boolean;
+    deepLink?: string;
+};

package/dist/lib/wallets/connectors/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/wallets/connectors/useSyncProviders/index.d.ts

@@ -1 +1 @@
-export declare const useSyncProviders: () => import("./EthereumProviderTypes").EIP6963ProviderDetail[];
+export declare const useSyncProviders: () => EIP6963ProviderDetail[];

package/dist/lib/wallets/connectors/useSyncProviders/store.d.ts

@@ -1,7 +1,9 @@
-import type { EIP6963ProviderDetail } from "./EthereumProviderTypes";
 declare global {
+    interface WindowEventMap {
+        "eip6963:announceProvider": CustomEvent<EIP6963AnnounceProviderEvent>;
+    }
 }
 export declare const store: {
     value: () => EIP6963ProviderDetail[];
-    subscribe: (callback: () => void) => () => void;
+    subscribe: (callback: (providers: EIP6963ProviderDetail[]) => void) => () => void;
 };

package/dist/lib/wallets/connectors/useSyncProviders/store.js

@@ -8,10 +8,12 @@ export const store = {
                 return;
             // Add the new provider to the list and call the provided callback function.
             providers = [...providers, event.detail];
-            callback();
+            callback([...providers, event.detail]);
         }
         window.addEventListener("eip6963:announceProvider", onAnnouncement);
         window.dispatchEvent(new Event("eip6963:requestProvider"));
-        return () => window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+        return () => {
+            window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+        };
     }
 };

package/dist/lib/wallets/evm/useEVM.d.ts

@@ -1,7 +1,2 @@
-import { Network } from "../../../Models/Network";
 import { WalletProvider } from "../../../Models/WalletProvider";
-type Props = {
-    network: Network | undefined;
-};
-export default function useEVM({ network }: Props): WalletProvider;
-export {};
+export default function useEVM(): WalletProvider;