@getpara/evm-wallet-connectors 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { EvmExternalWalletProvider, EvmExternalWalletContext } from './providers/EvmExternalWalletContext.js';
+export { ParaEvmProvider } from './providers/ParaEvmContext.js';
+export * from './wallets/connectors/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { EvmExternalWalletProvider, EvmExternalWalletContext } from './providers/EvmExternalWalletContext.js';
+export { ParaEvmProvider } from './providers/ParaEvmContext.js';
+export * from './wallets/connectors/index.js';

package/dist/providers/EvmExternalWalletContext.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { CommonChain, CommonWallet } from '../types/CommonTypes.js';
+import ParaWeb from '@getpara/react-sdk';
+export declare const defaultEvmExternalWallet: {
+    wallets: any[];
+    chains: any[];
+    chainId: any;
+    username: any;
+    avatar: any;
+    disconnect: () => Promise<void>;
+    switchChain: () => Promise<{}>;
+};
+export declare const EvmExternalWalletContext: import("react").Context<{
+    wallets: CommonWallet[];
+    chains: CommonChain[];
+    chainId: number;
+    username: string;
+    avatar?: string;
+    disconnect: () => Promise<void>;
+    switchChain: (chainId: number) => Promise<{
+        error?: string[];
+    }>;
+}>;
+interface EvmExternalWalletProviderProps {
+    children: ReactNode;
+    para: ParaWeb;
+    onSwitchWallet: (args: {
+        address?: string;
+        error?: string;
+    }) => void;
+}
+export declare function EvmExternalWalletProvider({ children, para, onSwitchWallet }: EvmExternalWalletProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/providers/EvmExternalWalletContext.js

@@ -0,0 +1,228 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useMemo, useState } from 'react';
+import { useAccount, useSwitchChain, useConnect, useDisconnect, useEnsName, useEnsAvatar } from 'wagmi';
+import { isEIP6963Connector } from '../utils/isEIP6963Connector.js';
+import { getWalletConnectUri } from '../utils/getWalletConnectUri.js';
+import { isMobile, WalletType } from '@getpara/react-sdk';
+import { normalize } from 'viem/ens';
+export const defaultEvmExternalWallet = {
+    wallets: [],
+    chains: [],
+    chainId: undefined,
+    username: undefined,
+    avatar: undefined,
+    disconnect: () => Promise.resolve(),
+    switchChain: () => Promise.resolve({}),
+};
+export const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+export function EvmExternalWalletProvider({ children, para, onSwitchWallet }) {
+    const { connectAsync, connectors: untypedConnectors } = useConnect();
+    const { address: wagmiAddress, isConnecting, isReconnecting, chainId, connector: connectedConnector } = useAccount();
+    const { chains, switchChainAsync } = useSwitchChain();
+    const { disconnectAsync } = useDisconnect();
+    const { data: ensName } = useEnsName({ address: wagmiAddress });
+    const { data: ensAvatar } = useEnsAvatar({
+        name: normalize(ensName),
+    });
+    const [isLocalConnecting, setIsLocalConnecting] = useState(false);
+    useEffect(() => {
+        const storedExternalWallet = para.externalWallets[wagmiAddress !== null && wagmiAddress !== void 0 ? wagmiAddress : ''];
+        if (!isConnecting &&
+            !isReconnecting &&
+            !isLocalConnecting &&
+            !!wagmiAddress &&
+            !storedExternalWallet &&
+            !((connectedConnector === null || connectedConnector === void 0 ? void 0 : connectedConnector.id) === 'para')) {
+            reset();
+        }
+    }, [isConnecting, isReconnecting, isLocalConnecting, wagmiAddress, connectedConnector]);
+    useEffect(() => {
+        var _a, _b;
+        const storedExternalWallet = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : ''];
+        // If the user is using an external EVM wallet we want to watch for wallet changes and log them in to a different user when the wallet changes
+        if (!isConnecting &&
+            !isReconnecting &&
+            (storedExternalWallet === null || storedExternalWallet === void 0 ? void 0 : storedExternalWallet.type) === WalletType.EVM &&
+            (storedExternalWallet === null || storedExternalWallet === void 0 ? void 0 : storedExternalWallet.address) !== wagmiAddress) {
+            switchWallet(wagmiAddress);
+        }
+    }, [wagmiAddress, isReconnecting, isConnecting]);
+    const connectors = untypedConnectors;
+    const reset = () => __awaiter(this, void 0, void 0, function* () {
+        yield disconnectAsync();
+        yield para.logout();
+    });
+    const switchChain = (chainId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let error;
+        try {
+            yield switchChainAsync({ chainId });
+        }
+        catch (e) {
+            // Invalid networks throws the same error as connection rejected requests, so catching the error using the detail string here.
+            if (e.details.includes('Missing or invalid.')) {
+                const chain = chains.find(c => c.id === chainId);
+                error = [
+                    'Network not supported.',
+                    `You may need to add ${chain === null || chain === void 0 ? void 0 : chain.name} support to ${(_c = (_b = (_a = connectedConnector === null || connectedConnector === void 0 ? void 0 : connectedConnector.paraDetails) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : connectedConnector === null || connectedConnector === void 0 ? void 0 : connectedConnector.name) !== null && _c !== void 0 ? _c : 'the wallet'} manually.`,
+                ];
+            }
+            else {
+                switch (e.name) {
+                    case 'UserRejectedRequestError': {
+                        error = ['Change request rejected'];
+                        break;
+                    }
+                    default: {
+                        error = ['An unknown error occurred'];
+                        break;
+                    }
+                }
+            }
+        }
+        return { error };
+    });
+    const login = (address, connectorName) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield para.externalWalletLogin({ address, type: WalletType.EVM, provider: connectorName });
+        }
+        catch (err) {
+            yield disconnectAsync();
+            yield para.logout();
+            throw 'Error logging you in. Please try again.';
+        }
+    });
+    const switchWallet = (address) => __awaiter(this, void 0, void 0, function* () {
+        setIsLocalConnecting(true);
+        let error;
+        // If we're calling switch wallet with no address, treat it as if the user disconnected the wallet from the app and logout to reset the Para instance.
+        if (!address) {
+            yield para.logout();
+        }
+        else {
+            try {
+                yield login(address, connectedConnector === null || connectedConnector === void 0 ? void 0 : connectedConnector.name);
+            }
+            catch (err) {
+                error = err;
+            }
+        }
+        onSwitchWallet({ address, error });
+        setIsLocalConnecting(false);
+    });
+    const connect = (connector) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        setIsLocalConnecting(true);
+        yield disconnectAsync();
+        const walletChainId = yield connector.getChainId();
+        let address;
+        let error;
+        try {
+            const data = yield connectAsync({
+                // If the wallet is already on a supported chain, use that to avoid a chain switch prompt.
+                chainId: (_b = (_a = chains.find(({ id }) => id === walletChainId)) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 
+                // Fall back to the first chain provided.
+                (_c = chains[0]) === null || _c === void 0 ? void 0 : _c.id,
+                connector,
+            });
+            address = (_d = data.accounts) === null || _d === void 0 ? void 0 : _d[0];
+            if (address) {
+                try {
+                    yield login(address, connector.name);
+                }
+                catch (err) {
+                    address = undefined;
+                    error = err;
+                }
+            }
+        }
+        catch (e) {
+            switch (e.name) {
+                case 'UserRejectedRequestError': {
+                    error = 'Connection request rejected';
+                    break;
+                }
+                case 'ResourceUnavailableRpcError': {
+                    `${connector.name} not detected`;
+                    break;
+                }
+                default: {
+                    error = 'An unknown error occurred';
+                    break;
+                }
+            }
+        }
+        setIsLocalConnecting(false);
+        return { address, error };
+    });
+    const connectMobile = (connector, isManualWalletConnect) => __awaiter(this, void 0, void 0, function* () {
+        const _isMobile = isManualWalletConnect !== undefined ? isManualWalletConnect : isMobile();
+        // If on mobile and the connector contains the wallet connect modal connector, use it.
+        const _connector = connector.walletConnectModalConnector && _isMobile ? connector.walletConnectModalConnector : connector;
+        return yield connect(_connector);
+    });
+    const getQrUri = (connector) => () => {
+        var _a;
+        return getWalletConnectUri(connector, (_a = connector.paraDetails) === null || _a === void 0 ? void 0 : _a.getUri);
+    };
+    // If an Eip6963 wallet is injected we want to remove the non Eip6963 connector and attach its metadata to the Eip6963 connector
+    const nonEip6963ConnectorsByRdns = {};
+    let walletConnectModalConnector;
+    connectors
+        .filter(c => !isEIP6963Connector(c))
+        .forEach(c => {
+        if (c.paraDetails) {
+            nonEip6963ConnectorsByRdns[c.paraDetails.rdns] = c.paraDetails;
+            if (c.paraDetails.isWalletConnectModalConnector) {
+                walletConnectModalConnector = c;
+            }
+        }
+    });
+    const eip6963ids = connectors.filter(c => isEIP6963Connector(c)).map(c => c.id);
+    const dedupedConnectors = connectors
+        .map(c => {
+        var _a, _b, _c;
+        // Filter out the duplicated walletConnect connector with the modal
+        // This connector will be attached to the WC connector that doesn't contain the modal for use on mobile
+        if ((_a = c.paraDetails) === null || _a === void 0 ? void 0 : _a.isWalletConnectModalConnector) {
+            return;
+        }
+        // Remove any non EIP6963 connectors if they have a matching EIP6963 connectors
+        if (!isEIP6963Connector(c) && eip6963ids.includes((_b = c.paraDetails) === null || _b === void 0 ? void 0 : _b.rdns)) {
+            return;
+        }
+        // Return the EIP6963 connectors
+        if (isEIP6963Connector(c)) {
+            const paraMetadata = nonEip6963ConnectorsByRdns[c.id];
+            return Object.assign(Object.assign({}, c), { paraDetails: paraMetadata });
+        }
+        // Return the WC connector with the attached WC modal connector
+        if (((_c = c.paraDetails) === null || _c === void 0 ? void 0 : _c.id) === 'walletConnect' && walletConnectModalConnector) {
+            return Object.assign(Object.assign({}, c), { walletConnectModalConnector });
+        }
+        return c;
+    })
+        .filter(c => !!c);
+    const wallets = dedupedConnectors.map(c => {
+        const connector = Object.assign(Object.assign({}, c), c.paraDetails);
+        return Object.assign(Object.assign({}, connector), { connect: () => connect(connector), connectMobile: isManualWalletConnect => connectMobile(connector, isManualWalletConnect), type: WalletType.EVM, getQrUri: getQrUri(connector) });
+    });
+    const formattedChains = chains.map(c => {
+        return {
+            id: c.id,
+            name: c.name,
+        };
+    });
+    const username = useMemo(() => ensName !== null && ensName !== void 0 ? ensName : wagmiAddress, [ensName, wagmiAddress]);
+    const disconnect = disconnectAsync;
+    return (_jsx(EvmExternalWalletContext.Provider, { value: useMemo(() => ({ wallets, chains: formattedChains, chainId, username, avatar: ensAvatar, disconnect, switchChain }), [wallets, formattedChains, chainId, username, ensAvatar, disconnect, switchChain]), children: children }));
+}

package/dist/providers/ParaEvmContext.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { CreateConfigParameters, WagmiProviderProps } from 'wagmi';
+import { WalletList } from '../types/Wallet.js';
+import { Chain, Transport } from 'viem';
+import ParaWeb from '@getpara/react-sdk';
+import { InjectedParameters } from 'wagmi/connectors';
+interface GetDefaultConfigParameters<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> extends Omit<CreateConfigParameters<chains, transports>, 'connectors'> {
+    appName: string;
+    appDescription?: string;
+    appUrl?: string;
+    appIcon?: string;
+    wallets?: WalletList;
+    projectId: string;
+    para?: ParaWeb;
+    paraDisableModal?: boolean;
+    paraOptions?: InjectedParameters;
+}
+interface ParaEvmProviderProps<chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>> extends Omit<WagmiProviderProps, 'config'> {
+    children: ReactNode;
+    config: GetDefaultConfigParameters<chains, transports>;
+}
+export declare function ParaEvmProvider<const chains extends readonly [Chain, ...Chain[]], transports extends Record<chains[number]['id'], Transport>>({ children, config: _config, ...wagmiProviderProps }: ParaEvmProviderProps<chains, transports>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/providers/ParaEvmContext.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo } from 'react';
+import { createConfig, WagmiProvider } from 'wagmi';
+import { connectorsForWallets } from '../wallets/connectorsForWallets.js';
+import { http } from 'viem';
+import { computeWalletConnectMetaData } from '../utils/computeWalletConnectMetaData.js';
+import { EvmExternalWalletContext, EvmExternalWalletProvider } from './EvmExternalWalletContext.js';
+import { useExternalWalletProviderStore } from '@getpara/react-sdk';
+import { connect } from 'wagmi/actions';
+import { paraConnector } from '@getpara/wagmi-v2-integration';
+const createDefaultTransports = (chains) => {
+    const transportsObject = chains.reduce((acc, chain) => {
+        const key = chain.id;
+        acc[key] = http(); // Type assertion here
+        return acc;
+    }, {});
+    return transportsObject;
+};
+export function ParaEvmProvider(_a) {
+    var { children, config: _config } = _a, wagmiProviderProps = __rest(_a, ["children", "config"]);
+    const updateExternalWalletProviderState = useExternalWalletProviderStore(state => state.updateState);
+    const EvmProvider = useExternalWalletProviderStore(state => state.EvmProvider);
+    const evmContext = useExternalWalletProviderStore(state => state.evmContext);
+    const { projectId, appName, appDescription, appIcon, appUrl, wallets, chains, transports, para, paraDisableModal, paraOptions } = _config, wagmiConfigParams = __rest(_config, ["projectId", "appName", "appDescription", "appIcon", "appUrl", "wallets", "chains", "transports", "para", "paraDisableModal", "paraOptions"]);
+    const wcMetadata = computeWalletConnectMetaData({ appName, appDescription, appUrl, appIcon });
+    const paraConnectorInstance = useMemo(() => {
+        if (!para)
+            return undefined;
+        const instance = paraConnector({
+            para,
+            chains: [...chains],
+            disableModal: paraDisableModal !== null && paraDisableModal !== void 0 ? paraDisableModal : true,
+            appName,
+            options: paraOptions !== null && paraOptions !== void 0 ? paraOptions : {},
+        });
+        return instance;
+    }, [para, chains, paraDisableModal, appName, paraOptions]);
+    const allConnectors = useMemo(() => {
+        const baseConnectors = connectorsForWallets(wallets, {
+            projectId,
+            appName,
+            appDescription,
+            appUrl,
+            appIcon,
+            walletConnectParameters: { metadata: wcMetadata },
+        });
+        return paraConnectorInstance ? [...baseConnectors, paraConnectorInstance] : baseConnectors;
+    }, [wallets, projectId, appName, appDescription, appUrl, appIcon, wcMetadata, paraConnectorInstance]);
+    const config = useMemo(() => createConfig(Object.assign(Object.assign({}, wagmiConfigParams), { chains, transports: transports || createDefaultTransports(chains), connectors: allConnectors })), [wagmiConfigParams, chains, transports, allConnectors]);
+    const connectParaEvmWallet = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        if (!paraConnectorInstance) {
+            return { error: 'No para connector instance' };
+        }
+        try {
+            const result = yield connect(config, { connector: paraConnectorInstance });
+            return { result };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : 'Unknown error';
+            return { error };
+        }
+    }), [paraConnectorInstance, config, connect]);
+    useEffect(() => {
+        updateExternalWalletProviderState({
+            EvmProvider: evmContext && EvmProvider ? EvmProvider : EvmExternalWalletProvider,
+            evmContext: evmContext || EvmExternalWalletContext,
+            connectParaEvmWallet: paraConnectorInstance ? connectParaEvmWallet : undefined,
+        });
+    }, [evmContext, EvmProvider, paraConnectorInstance, connectParaEvmWallet, updateExternalWalletProviderState]);
+    if (!evmContext || !EvmProvider) {
+        return null;
+    }
+    return (_jsx(WagmiProvider, Object.assign({ config: config }, wagmiProviderProps, { children: children })));
+}

package/dist/types/CommonTypes.d.ts

@@ -0,0 +1,27 @@
+export type WalletMetadata = {
+    id: string;
+    name: string;
+    rdns?: string;
+    iconUrl: string;
+    installed?: boolean;
+    isExtension?: boolean;
+    isMobile?: boolean;
+    isWeb?: boolean;
+    downloadUrl?: string;
+    getQrUri?: () => Promise<string>;
+};
+export type CommonWallet = {
+    connect: () => Promise<{
+        address?: string;
+        error?: string;
+    }>;
+    connectMobile: (isManualWalletConnect?: boolean) => Promise<{
+        address?: string;
+        error?: string;
+    }>;
+    type: 'EVM' | 'SOLANA' | 'COSMOS';
+} & WalletMetadata;
+export type CommonChain = {
+    id: string | number;
+    name: string;
+};

package/dist/types/CommonTypes.js

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

package/dist/types/Wallet.d.ts

@@ -0,0 +1,32 @@
+import { Connector, CreateConnectorFn } from 'wagmi';
+import { WalletConnectParameters } from 'wagmi/connectors';
+import { CoinbaseWalletOptions } from '../wallets/connectors/coinbase/coinbase.js';
+import { WalletConnectWalletOptions } from '../wallets/connectors/walletConnect/walletConnect.js';
+import { WalletMetadata } from './CommonTypes.js';
+export type Wallet = {
+    createConnector?: (walletDetails: WalletDetailsParams) => CreateConnectorFn;
+    createMobileConnector?: (walletDetails: WalletDetailsParams) => CreateConnectorFn;
+    getUri?: (uri: string) => string;
+} & WalletMetadata;
+export interface DefaultWalletOptions {
+    projectId: string;
+    walletConnectParameters?: ParaWalletConnectParameters;
+}
+export type CreateWalletFn = (createWalletParams: CoinbaseWalletOptions & Omit<WalletConnectWalletOptions, 'projectId'> & DefaultWalletOptions) => Wallet;
+export type WalletList = CreateWalletFn[];
+export type ParaWalletConnectParameters = Omit<WalletConnectParameters, 'showQrModal' | 'projectId'>;
+export type ParaDetails = Omit<Wallet, 'createConnector' | 'createWCConnector' | 'hidden'> & {
+    isWalletConnectModalConnector?: boolean;
+    isParaConnector: boolean;
+    walletConnectModalConnector?: Connector;
+    showQrModal?: true;
+};
+export type WalletDetailsParams = {
+    paraDetails: ParaDetails;
+};
+export type CreateConnector = (walletDetails: WalletDetailsParams) => CreateConnectorFn;
+export type WagmiConnectorInstance = Connector & {
+    paraDetails?: ParaDetails;
+    walletConnectModalConnector?: WagmiConnectorInstance;
+};
+export type WalletInstance = Connector & ParaDetails;

package/dist/types/Wallet.js

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

package/dist/types/utils.d.ts

@@ -0,0 +1,37 @@
+import { EIP1193Provider } from 'viem';
+/** Combines members of an intersection into a readable type. */
+export type Evaluate<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+/** Removes `readonly` from all properties of an object. */
+export type Mutable<type extends object> = {
+    -readonly [key in keyof type]: type[key];
+};
+/** Strict version of built-in Omit type */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+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';
+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;
+};

package/dist/types/utils.js

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

package/dist/utils/computeWalletConnectMetaData.d.ts

@@ -0,0 +1,9 @@
+import { ParaWalletConnectParameters } from '../types/Wallet.js';
+interface ComputeMetaDataParameters {
+    appName: string;
+    appDescription?: string;
+    appUrl?: string;
+    appIcon?: string;
+}
+export declare const computeWalletConnectMetaData: ({ appName, appDescription, appUrl, appIcon, }: ComputeMetaDataParameters) => ParaWalletConnectParameters["metadata"];
+export {};

package/dist/utils/computeWalletConnectMetaData.js

@@ -0,0 +1,8 @@
+export const computeWalletConnectMetaData = ({ appName, appDescription, appUrl, appIcon, }) => {
+    return {
+        name: appName,
+        description: appDescription !== null && appDescription !== void 0 ? appDescription : appName,
+        url: appUrl !== null && appUrl !== void 0 ? appUrl : (typeof window !== 'undefined' ? window.location.href : ''),
+        icons: [...(appIcon ? [appIcon] : [])],
+    };
+};

package/dist/utils/getInjectedConnector.d.ts

@@ -0,0 +1,11 @@
+import { WalletProviderFlags } from '../types/utils.js';
+import { CreateConnector } from '../types/Wallet.js';
+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/utils/getInjectedConnector.js

@@ -0,0 +1,81 @@
+import { createConnector } from 'wagmi';
+import { injected } from 'wagmi/connectors';
+/*
+ * 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;
+}
+/*
+ * 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 }) {
+    var _a;
+    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 = (_a = _window.ethereum) === null || _a === void 0 ? void 0 : _a.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.paraDetails.id,
+                    name: walletDetails.paraDetails.name,
+                    provider,
+                }),
+            }
+            : {};
+        return createConnector(config => (Object.assign(Object.assign({}, injected(injectedConfig)(config)), walletDetails)));
+    };
+}
+export function getInjectedConnector({ flag, namespace, target, }) {
+    const provider = target ? target : getInjectedProvider({ flag, namespace });
+    return createInjectedConnector(provider);
+}

package/dist/utils/getWalletConnectConnector.d.ts

@@ -0,0 +1,7 @@
+import type { CreateConnector, ParaWalletConnectParameters } from '../types/Wallet.js';
+interface GetWalletConnectConnectorParams {
+    projectId: string;
+    walletConnectParameters?: ParaWalletConnectParameters;
+}
+export declare function getWalletConnectConnector({ projectId, walletConnectParameters, }: GetWalletConnectConnectorParams): CreateConnector;
+export {};