@layerswap/widget 0.1.18 → 1.0.0-alpha0.1

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

@@ -1,360 +0,0 @@
-import { ChainNotConfiguredError, ProviderNotFoundError, createConnector, extractRpcUrls, } from '@wagmi/core';
-import { SwitchChainError, UserRejectedRequestError, getAddress, numberToHex, } from 'viem';
-import { isAndroid } from '../utils/isMobile';
-bitget.type = 'my_walletConnect';
-export function bitget(parameters) {
-    const isNewChainsStale = parameters.isNewChainsStale ?? true;
-    let provider_;
-    let providerPromise;
-    const NAMESPACE = 'eip155';
-    let accountsChanged;
-    let chainChanged;
-    let connect;
-    let displayUri;
-    let sessionDelete;
-    let disconnect;
-    return createConnector((config) => {
-        return ({
-            id: 'bitget',
-            name: 'BitGet',
-            rdns: 'com.bitget.web3',
-            deepLink: 'bitkeep://wc',
-            resolveURI: (uri) => {
-                return isAndroid()
-                    ? uri
-                    : `bitkeep://wc?uri=${encodeURIComponent(uri)}`;
-            },
-            type: bitget.type,
-            async setup() {
-                const provider = await this.getProvider().catch(() => null);
-                if (!provider)
-                    return;
-                if (!connect) {
-                    connect = this.onConnect.bind(this);
-                    provider.on('connect', connect);
-                }
-                if (!sessionDelete) {
-                    sessionDelete = this.onSessionDelete.bind(this);
-                    provider.on('session_delete', sessionDelete);
-                }
-            },
-            async connect({ chainId, ...rest } = {}) {
-                try {
-                    const provider = await this.getProvider();
-                    if (!provider)
-                        throw new ProviderNotFoundError();
-                    if (!displayUri) {
-                        displayUri = this.onDisplayUri;
-                        provider.on('display_uri', displayUri);
-                    }
-                    let targetChainId = chainId;
-                    if (!targetChainId) {
-                        const state = (await config.storage?.getItem('state')) ?? {};
-                        const isChainSupported = config.chains.some((x) => x.id === state.chainId);
-                        if (isChainSupported)
-                            targetChainId = state.chainId;
-                        else
-                            targetChainId = config.chains[0]?.id;
-                    }
-                    if (!targetChainId)
-                        throw new Error('No chains found on connector.');
-                    const isChainsStale = await this.isChainsStale();
-                    // If there is an active session with stale chains, disconnect current session.
-                    if (provider.session && isChainsStale)
-                        await provider.disconnect();
-                    // If there isn't an active session or chains are stale, connect.
-                    if (!provider.session || isChainsStale) {
-                        const optionalChains = config.chains
-                            .filter((chain) => chain.id !== targetChainId)
-                            .map((optionalChain) => optionalChain.id);
-                        await provider.connect({
-                            optionalChains: [targetChainId, ...optionalChains],
-                            ...('pairingTopic' in rest
-                                ? { pairingTopic: rest.pairingTopic }
-                                : {}),
-                        });
-                        this.setRequestedChainsIds(config.chains.map((x) => x.id));
-                    }
-                    // If session exists and chains are authorized, enable provider for required chain
-                    const accounts = (await provider.enable()).map((x) => getAddress(x));
-                    const currentChainId = await this.getChainId();
-                    if (displayUri) {
-                        provider.removeListener('display_uri', displayUri);
-                        displayUri = undefined;
-                    }
-                    if (connect) {
-                        provider.removeListener('connect', connect);
-                        connect = undefined;
-                    }
-                    if (!accountsChanged) {
-                        accountsChanged = this.onAccountsChanged.bind(this);
-                        provider.on('accountsChanged', accountsChanged);
-                    }
-                    if (!chainChanged) {
-                        chainChanged = this.onChainChanged.bind(this);
-                        provider.on('chainChanged', chainChanged);
-                    }
-                    if (!disconnect) {
-                        disconnect = this.onDisconnect.bind(this);
-                        provider.on('disconnect', disconnect);
-                    }
-                    if (!sessionDelete) {
-                        sessionDelete = this.onSessionDelete.bind(this);
-                        provider.on('session_delete', sessionDelete);
-                    }
-                    return { accounts, chainId: currentChainId };
-                }
-                catch (error) {
-                    if (/(user rejected|connection request reset)/i.test(error?.message)) {
-                        throw new UserRejectedRequestError(error);
-                    }
-                    throw error;
-                }
-            },
-            async disconnect() {
-                const provider = await this.getProvider();
-                try {
-                    await provider?.disconnect();
-                }
-                catch (error) {
-                    if (!/No matching key/i.test(error.message))
-                        throw error;
-                }
-                finally {
-                    if (chainChanged) {
-                        provider?.removeListener('chainChanged', chainChanged);
-                        chainChanged = undefined;
-                    }
-                    if (disconnect) {
-                        provider?.removeListener('disconnect', disconnect);
-                        disconnect = undefined;
-                    }
-                    if (!connect) {
-                        connect = this.onConnect.bind(this);
-                        provider?.on('connect', connect);
-                    }
-                    if (accountsChanged) {
-                        provider?.removeListener('accountsChanged', accountsChanged);
-                        accountsChanged = undefined;
-                    }
-                    if (sessionDelete) {
-                        provider?.removeListener('session_delete', sessionDelete);
-                        sessionDelete = undefined;
-                    }
-                    this.setRequestedChainsIds([]);
-                }
-            },
-            async getAccounts() {
-                const provider = await this.getProvider();
-                return provider.accounts.map((x) => getAddress(x));
-            },
-            async getProvider({ chainId } = {}) {
-                async function initProvider() {
-                    const optionalChains = config.chains.map((x) => x.id);
-                    if (!optionalChains.length)
-                        return;
-                    const { EthereumProvider } = await import('@walletconnect/ethereum-provider');
-                    return await EthereumProvider.init({
-                        ...parameters,
-                        disableProviderPing: true,
-                        optionalChains,
-                        projectId: parameters.projectId,
-                        rpcMap: Object.fromEntries(config.chains.map((chain) => {
-                            const [url] = extractRpcUrls({
-                                chain,
-                                transports: config.transports,
-                            });
-                            return [chain.id, url];
-                        })),
-                        showQrModal: parameters.showQrModal ?? true,
-                    });
-                }
-                if (!provider_) {
-                    if (!providerPromise)
-                        providerPromise = initProvider();
-                    provider_ = await providerPromise;
-                    provider_?.events.setMaxListeners(Number.POSITIVE_INFINITY);
-                }
-                if (chainId)
-                    await this.switchChain?.({ chainId });
-                return provider_;
-            },
-            async getChainId() {
-                const provider = await this.getProvider();
-                return provider.chainId;
-            },
-            async isAuthorized() {
-                try {
-                    const [accounts, provider] = await Promise.all([
-                        this.getAccounts(),
-                        this.getProvider(),
-                    ]);
-                    // If an account does not exist on the session, then the connector is unauthorized.
-                    if (!accounts.length)
-                        return false;
-                    // If the chains are stale on the session, then the connector is unauthorized.
-                    const isChainsStale = await this.isChainsStale();
-                    if (isChainsStale && provider.session) {
-                        await provider.disconnect().catch(() => { });
-                        return false;
-                    }
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            },
-            async switchChain({ addEthereumChainParameter, chainId }) {
-                const provider = await this.getProvider();
-                if (!provider)
-                    throw new ProviderNotFoundError();
-                const chain = config.chains.find((x) => x.id === chainId);
-                if (!chain)
-                    throw new SwitchChainError(new ChainNotConfiguredError());
-                try {
-                    await Promise.all([
-                        new Promise((resolve) => {
-                            const listener = ({ chainId: currentChainId, }) => {
-                                if (currentChainId === chainId) {
-                                    config.emitter.off('change', listener);
-                                    resolve();
-                                }
-                            };
-                            config.emitter.on('change', listener);
-                        }),
-                        provider.request({
-                            method: 'wallet_switchEthereumChain',
-                            params: [{ chainId: numberToHex(chainId) }],
-                        }),
-                    ]);
-                    const requestedChains = await this.getRequestedChainsIds();
-                    this.setRequestedChainsIds([...requestedChains, chainId]);
-                    return chain;
-                }
-                catch (err) {
-                    const error = err;
-                    if (/(user rejected)/i.test(error.message))
-                        throw new UserRejectedRequestError(error);
-                    // Indicates chain is not added to provider
-                    try {
-                        let blockExplorerUrls;
-                        if (addEthereumChainParameter?.blockExplorerUrls)
-                            blockExplorerUrls = addEthereumChainParameter.blockExplorerUrls;
-                        else
-                            blockExplorerUrls = chain.blockExplorers?.default.url
-                                ? [chain.blockExplorers?.default.url]
-                                : [];
-                        let rpcUrls;
-                        if (addEthereumChainParameter?.rpcUrls?.length)
-                            rpcUrls = addEthereumChainParameter.rpcUrls;
-                        else
-                            rpcUrls = [...chain.rpcUrls.default.http];
-                        const addEthereumChain = {
-                            blockExplorerUrls,
-                            chainId: numberToHex(chainId),
-                            chainName: addEthereumChainParameter?.chainName ?? chain.name,
-                            iconUrls: addEthereumChainParameter?.iconUrls,
-                            nativeCurrency: addEthereumChainParameter?.nativeCurrency ?? chain.nativeCurrency,
-                            rpcUrls,
-                        };
-                        await provider.request({
-                            method: 'wallet_addEthereumChain',
-                            params: [addEthereumChain],
-                        });
-                        const requestedChains = await this.getRequestedChainsIds();
-                        this.setRequestedChainsIds([...requestedChains, chainId]);
-                        return chain;
-                    }
-                    catch (error) {
-                        throw new UserRejectedRequestError(error);
-                    }
-                }
-            },
-            onAccountsChanged(accounts) {
-                if (accounts.length === 0)
-                    this.onDisconnect();
-                else
-                    config.emitter.emit('change', {
-                        accounts: accounts.map((x) => getAddress(x)),
-                    });
-            },
-            onChainChanged(chain) {
-                const chainId = Number(chain);
-                config.emitter.emit('change', { chainId });
-            },
-            async onConnect(connectInfo) {
-                const chainId = Number(connectInfo.chainId);
-                const accounts = await this.getAccounts();
-                config.emitter.emit('connect', { accounts, chainId });
-            },
-            async onDisconnect(_error) {
-                this.setRequestedChainsIds([]);
-                config.emitter.emit('disconnect');
-                const provider = await this.getProvider();
-                if (accountsChanged) {
-                    provider.removeListener('accountsChanged', accountsChanged);
-                    accountsChanged = undefined;
-                }
-                if (chainChanged) {
-                    provider.removeListener('chainChanged', chainChanged);
-                    chainChanged = undefined;
-                }
-                if (disconnect) {
-                    provider.removeListener('disconnect', disconnect);
-                    disconnect = undefined;
-                }
-                if (sessionDelete) {
-                    provider.removeListener('session_delete', sessionDelete);
-                    sessionDelete = undefined;
-                }
-                if (!connect) {
-                    connect = this.onConnect.bind(this);
-                    provider.on('connect', connect);
-                }
-            },
-            onDisplayUri(uri) {
-                config.emitter.emit('message', { type: 'display_uri', data: uri });
-            },
-            onSessionDelete() {
-                this.onDisconnect();
-            },
-            getNamespaceChainsIds() {
-                if (!provider_)
-                    return [];
-                const chainIds = provider_.session?.namespaces[NAMESPACE]?.accounts?.map((account) => Number.parseInt(account.split(':')[1] || ''));
-                return chainIds ?? [];
-            },
-            async getRequestedChainsIds() {
-                return ((await config.storage?.getItem(this.requestedChainsStorageKey)) ?? []);
-            },
-            /**
-             * Checks if the target chains match the chains that were
-             * initially requested by the connector for the WalletConnect sessionsession.
-             * If there is a mismatch, this means that the chains on the connector
-             * are considered stale, and need to be revalidated at a later point (via
-             * connection).
-             *
-             * There may be a scenario where a dapp adds a chain to the
-             * connector later on, however, this chain will not have been approved or rejected
-             * by the wallet. In this case, the chain is considered stale.
-             */
-            async isChainsStale() {
-                if (!isNewChainsStale)
-                    return false;
-                const connectorChains = config.chains.map((x) => x.id);
-                const namespaceChains = this.getNamespaceChainsIds();
-                if (namespaceChains.length &&
-                    !namespaceChains.some((id) => connectorChains.includes(id)))
-                    return false;
-                const requestedChains = await this.getRequestedChainsIds();
-                return !connectorChains.every((id) => requestedChains.includes(id));
-            },
-            async setRequestedChainsIds(chains) {
-                await config.storage?.setItem(this.requestedChainsStorageKey, chains);
-            },
-            get requestedChainsStorageKey() {
-                return `${this.id}.requestedChains`;
-            },
-        });
-    });
-}

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

@@ -1,2 +0,0 @@
-export * from "./values";
-export * from "./rpc";

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

@@ -1,2 +0,0 @@
-export * from "./values";
-export * from "./rpc";

package/dist/lib/wallets/connectors/constants/rpc.d.ts

@@ -1,4 +0,0 @@
-export declare const REQUIRED_METHODS: string[];
-export declare const OPTIONAL_METHODS: string[];
-export declare const REQUIRED_EVENTS: string[];
-export declare const OPTIONAL_EVENTS: string[];

package/dist/lib/wallets/connectors/constants/rpc.js

@@ -1,32 +0,0 @@
-export const REQUIRED_METHODS = ["eth_sendTransaction", "personal_sign"];
-export const OPTIONAL_METHODS = [
-    "eth_accounts",
-    "eth_requestAccounts",
-    "eth_sendRawTransaction",
-    "eth_sign",
-    "eth_signTransaction",
-    "eth_signTypedData",
-    "eth_signTypedData_v3",
-    "eth_signTypedData_v4",
-    "eth_sendTransaction",
-    "personal_sign",
-    "wallet_switchEthereumChain",
-    "wallet_addEthereumChain",
-    "wallet_getPermissions",
-    "wallet_requestPermissions",
-    "wallet_registerOnboarding",
-    "wallet_watchAsset",
-    "wallet_scanQRCode",
-    "wallet_sendCalls",
-    "wallet_getCapabilities",
-    "wallet_getCallsStatus",
-    "wallet_showCallsStatus",
-];
-export const REQUIRED_EVENTS = ["chainChanged", "accountsChanged"];
-export const OPTIONAL_EVENTS = [
-    "chainChanged",
-    "accountsChanged",
-    "message",
-    "disconnect",
-    "connect",
-];

package/dist/lib/wallets/connectors/constants/values.d.ts

@@ -1,5 +0,0 @@
-export declare const PROTOCOL = "wc";
-export declare const WC_VERSION = 2;
-export declare const CONTEXT = "ethereum_provider";
-export declare const STORAGE_KEY = "wc@2:ethereum_provider:";
-export declare const RPC_URL = "https://rpc.walletconnect.org/v1/";

package/dist/lib/wallets/connectors/constants/values.js

@@ -1,5 +0,0 @@
-export const PROTOCOL = "wc";
-export const WC_VERSION = 2;
-export const CONTEXT = "ethereum_provider";
-export const STORAGE_KEY = `${PROTOCOL}@${WC_VERSION}:${CONTEXT}:`;
-export const RPC_URL = "https://rpc.walletconnect.org/v1/";

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

@@ -1,11 +0,0 @@
-import { WalletProviderFlags, CreateConnector } from './EthereumProvider';
-export declare function explicitInjectedproviderDetected(): boolean;
-export declare function hasInjectedProvider({ flag, namespace, }: {
-    flag?: WalletProviderFlags;
-    namespace?: string;
-}): boolean;
-export declare function getInjectedConnector({ flag, namespace, target, }: {
-    flag?: WalletProviderFlags;
-    namespace?: string;
-    target?: any;
-}): CreateConnector;

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

@@ -1,95 +0,0 @@
-import { createConnector } from 'wagmi';
-import { injected } from '@wagmi/connectors';
-// import type { CreateConnector, WalletDetailsParams } from './Wallet';
-/*
- * Returns the explicit window provider that matches the flag and the flag is true
- */
-function getExplicitInjectedProvider(flag) {
-    const _window = typeof window !== 'undefined' ? window : undefined;
-    if (typeof _window === 'undefined' || typeof _window.ethereum === 'undefined')
-        return;
-    const providers = _window.ethereum.providers;
-    return providers
-        ? providers.find((provider) => provider[flag])
-        : _window.ethereum[flag]
-            ? _window.ethereum
-            : undefined;
-}
-export function explicitInjectedproviderDetected() {
-    const _window = typeof window !== 'undefined' ? window : undefined;
-    if (typeof _window === 'undefined' || typeof _window.ethereum === 'undefined')
-        return false;
-    return !!_window.ethereum;
-}
-/*
- * Gets the `window.namespace` window provider if it exists
- */
-function getWindowProviderNamespace(namespace) {
-    const providerSearch = (provider, namespace) => {
-        const [property, ...path] = namespace.split('.');
-        const _provider = provider[property];
-        if (_provider) {
-            if (path.length === 0)
-                return _provider;
-            return providerSearch(_provider, path.join('.'));
-        }
-    };
-    if (typeof window !== 'undefined')
-        return providerSearch(window, namespace);
-}
-/*
- * Checks if the explict provider or window ethereum exists
- */
-export function hasInjectedProvider({ flag, namespace, }) {
-    if (namespace && typeof getWindowProviderNamespace(namespace) !== 'undefined')
-        return true;
-    if (flag && typeof getExplicitInjectedProvider(flag) !== 'undefined')
-        return true;
-    return false;
-}
-/*
- * Returns an injected provider that favors the flag match, but falls back to window.ethereum
- */
-function getInjectedProvider({ flag, namespace, }) {
-    const _window = typeof window !== 'undefined' ? window : undefined;
-    if (typeof _window === 'undefined')
-        return;
-    if (namespace) {
-        // prefer custom eip1193 namespaces
-        const windowProvider = getWindowProviderNamespace(namespace);
-        if (windowProvider)
-            return windowProvider;
-    }
-    const providers = _window.ethereum?.providers;
-    if (flag) {
-        const provider = getExplicitInjectedProvider(flag);
-        if (provider)
-            return provider;
-    }
-    if (typeof providers !== 'undefined' && providers.length > 0)
-        return providers[0];
-    return _window.ethereum;
-}
-function createInjectedConnector(provider) {
-    return (walletDetails) => {
-        // Create the injected configuration object conditionally based on the provider.
-        const injectedConfig = provider
-            ? {
-                target: () => ({
-                    id: walletDetails.id,
-                    name: walletDetails.name,
-                    provider,
-                }),
-            }
-            : {};
-        return createConnector((config) => ({
-            // Spread the injectedConfig object, which may be empty or contain the target function
-            ...injected(injectedConfig)(config),
-            ...walletDetails,
-        }));
-    };
-}
-export function getInjectedConnector({ flag, namespace, target, }) {
-    const provider = target ? target : getInjectedProvider({ flag, namespace });
-    return createInjectedConnector(provider);
-}

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

@@ -1,63 +0,0 @@
-import type { Compute, ExactPartial, Omit } from '@wagmi/core/internal';
-import type { EthereumProvider } from '@walletconnect/ethereum-provider';
-import { type Address, type ProviderConnectInfo } from 'viem';
-type EthereumProviderOptions = Parameters<(typeof EthereumProvider)['init']>[0];
-export type WalletConnectParameters = Compute<{
-    /**
-     * If a new chain is added to a previously existing configured connector `chains`, this flag
-     * will determine if that chain should be considered as stale. A stale chain is a chain that
-     * WalletConnect has yet to establish a relationship with (e.g. the user has not approved or
-     * rejected the chain).
-     *
-     * This flag mainly affects the behavior when a wallet does not support dynamic chain authorization
-     * with WalletConnect v2.
-     *
-     * If `true` (default), the new chain will be treated as a stale chain. If the user
-     * has yet to establish a relationship (approved/rejected) with this chain in their WalletConnect
-     * session, the connector will disconnect upon the dapp auto-connecting, and the user will have to
-     * reconnect to the dapp (revalidate the chain) in order to approve the newly added chain.
-     * This is the default behavior to avoid an unexpected error upon switching chains which may
-     * be a confusing user experience (e.g. the user will not know they have to reconnect
-     * unless the dapp handles these types of errors).
-     *
-     * If `false`, the new chain will be treated as a potentially valid chain. This means that if the user
-     * has yet to establish a relationship with the chain in their WalletConnect session, wagmi will successfully
-     * auto-connect the user. This comes with the trade-off that the connector will throw an error
-     * when attempting to switch to the unapproved chain if the wallet does not support dynamic session updates.
-     * This may be useful in cases where a dapp constantly
-     * modifies their configured chains, and they do not want to disconnect the user upon
-     * auto-connecting. If the user decides to switch to the unapproved chain, it is important that the
-     * dapp handles this error and prompts the user to reconnect to the dapp in order to approve
-     * the newly added chain.
-     *
-     * @default true
-     */
-    isNewChainsStale?: boolean;
-} & Omit<EthereumProviderOptions, 'chains' | 'events' | 'optionalChains' | 'optionalEvents' | 'optionalMethods' | 'methods' | 'rpcMap' | 'showQrModal'> & ExactPartial<Pick<EthereumProviderOptions, 'showQrModal'>> & {
-    id: string;
-    name: string;
-}>;
-export declare function walletConnect(parameters: WalletConnectParameters): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, Properties, StorageItem>;
-type Properties = {
-    connect(parameters?: {
-        chainId?: number;
-        pairingTopic?: string;
-    }): Promise<{
-        accounts: readonly Address[];
-        chainId: number;
-    }>;
-    getNamespaceChainsIds(): number[];
-    getRequestedChainsIds(): Promise<number[]>;
-    isChainsStale(): Promise<boolean>;
-    onConnect(connectInfo: ProviderConnectInfo): void;
-    onDisplayUri(uri: string): void;
-    onSessionDelete(data: {
-        topic: string;
-    }): void;
-    setRequestedChainsIds(chains: number[]): void;
-    requestedChainsStorageKey: `${string}.requestedChains`;
-};
-type StorageItem = {
-    [_ in Properties['requestedChainsStorageKey']]: number[];
-};
-export {};