@openfort/react 0.3.2 → 1.0.0

package/build/wagmi/useWalletAuth.js

@@ -0,0 +1,180 @@
+import { useState, useMemo, useCallback } from 'react';
+import { embeddedWalletId } from '../constants/openfort.js';
+import { OpenfortError, OpenfortReactErrorType } from '../types.js';
+import { useEthereumBridge } from '../ethereum/OpenfortEthereumBridgeContext.js';
+import { mapStatus } from '../hooks/openfort/auth/status.js';
+import { onError, onSuccess } from '../hooks/openfort/hookConsistency.js';
+import { useOpenfortCore } from '../openfort/useOpenfort.js';
+import { createSIWEMessage } from '../siwe/create-siwe-message.js';
+
+function runConnectWithSiwe(bridge, openfort, params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    const { client, updateUser } = openfort;
+    const address = (_a = params.address) !== null && _a !== void 0 ? _a : (_b = bridge.account) === null || _b === void 0 ? void 0 : _b.address;
+    const connectorType = (_c = params.connectorType) !== null && _c !== void 0 ? _c : (_e = (_d = bridge.account) === null || _d === void 0 ? void 0 : _d.connector) === null || _e === void 0 ? void 0 : _e.type;
+    const walletClientType = (_f = params.walletClientType) !== null && _f !== void 0 ? _f : (_h = (_g = bridge.account) === null || _g === void 0 ? void 0 : _g.connector) === null || _h === void 0 ? void 0 : _h.id;
+    const chainId = (_j = bridge.chainId) !== null && _j !== void 0 ? _j : 0;
+    const accountChainId = (_m = (_l = (_k = bridge.account) === null || _k === void 0 ? void 0 : _k.chain) === null || _l === void 0 ? void 0 : _l.id) !== null && _m !== void 0 ? _m : bridge.chainId;
+    const chainName = (_p = (_o = bridge.account) === null || _o === void 0 ? void 0 : _o.chain) === null || _p === void 0 ? void 0 : _p.name;
+    const switchChainAsync = (_q = bridge.switchChain) === null || _q === void 0 ? void 0 : _q.switchChainAsync;
+    const signMessage = bridge.signMessage;
+    if (!address || !connectorType || !walletClientType) {
+        (_r = params.onError) === null || _r === void 0 ? void 0 : _r.call(params, 'No address found');
+        return Promise.resolve();
+    }
+    if (!signMessage) {
+        (_s = params.onError) === null || _s === void 0 ? void 0 : _s.call(params, 'EVM bridge not available (signMessage)');
+        return Promise.resolve();
+    }
+    return (async () => {
+        var _a;
+        try {
+            if (accountChainId !== chainId && switchChainAsync) {
+                await switchChainAsync({ chainId });
+            }
+            const nonce = params.link
+                ? (await client.auth.initLinkSiwe({ address })).nonce
+                : (await client.auth.initSiwe({ address })).nonce;
+            const siweMsg = createSIWEMessage(address, nonce, chainId);
+            if (!siweMsg)
+                throw new Error('SIWE message creation failed (window not available)');
+            const messageStr = typeof siweMsg === 'string'
+                ? siweMsg
+                : typeof siweMsg.prepareMessage === 'function'
+                    ? await siweMsg.prepareMessage()
+                    : String(siweMsg);
+            const signature = await signMessage({ message: messageStr });
+            if (params.link) {
+                await client.auth.linkWithSiwe({
+                    signature,
+                    message: messageStr,
+                    connectorType,
+                    walletClientType,
+                    address,
+                    chainId,
+                });
+            }
+            else {
+                await client.auth.loginWithSiwe({
+                    signature,
+                    message: messageStr,
+                    connectorType,
+                    walletClientType,
+                    address,
+                });
+            }
+            await updateUser();
+            (_a = params.onConnect) === null || _a === void 0 ? void 0 : _a.call(params);
+        }
+        catch (err) {
+            if (!params.onError)
+                return;
+            let message = err instanceof Error ? err.message : String(err);
+            if (message.includes('User rejected the request.'))
+                message = 'User rejected the request.';
+            else if (message.includes('Invalid signature'))
+                message = 'Invalid signature. Please try again.';
+            else if (message.includes('An error occurred when attempting to switch chain')) {
+                message = `Failed to switch chain. Please switch your wallet to ${chainName !== null && chainName !== void 0 ? chainName : 'the correct network'} and try again.`;
+            }
+            else if (message.includes('already linked')) {
+                message = 'This wallet is already linked to another account. Log out and connect with this wallet instead.';
+            }
+            else {
+                message = 'Failed to connect with SIWE.';
+            }
+            params.onError(message, err instanceof OpenfortError ? err : undefined);
+        }
+    })();
+}
+function useWalletAuth(hookOptions = {}) {
+    const bridge = useEthereumBridge();
+    const openfort = useOpenfortCore();
+    const [walletConnectingTo, setWalletConnectingTo] = useState(null);
+    const [status, setStatus] = useState({ status: 'idle' });
+    const availableWallets = useMemo(() => {
+        var _a;
+        if (!((_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _a === void 0 ? void 0 : _a.length))
+            return [];
+        return bridge.connectors
+            .filter((c) => c.id !== embeddedWalletId)
+            .map((c) => { var _a; return ({ id: c.id, name: (_a = c.name) !== null && _a !== void 0 ? _a : c.id, icon: c.icon, connector: c }); });
+    }, [bridge === null || bridge === void 0 ? void 0 : bridge.connectors]);
+    const runConnectThenSiwe = useCallback(async (connectorId, link, callbacks) => {
+        var _a, _b, _c, _d, _e;
+        const connector = (_a = bridge === null || bridge === void 0 ? void 0 : bridge.connectors) === null || _a === void 0 ? void 0 : _a.find((c) => c.id === connectorId);
+        if (!connector || !(bridge === null || bridge === void 0 ? void 0 : bridge.connectAsync)) {
+            const msg = 'Connector not available';
+            const err = new OpenfortError(msg, OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            setStatus({ status: 'error', error: err });
+            onError({ hookOptions, error: err });
+            (_b = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _b === void 0 ? void 0 : _b.call(callbacks, msg, err);
+            return;
+        }
+        setWalletConnectingTo(connectorId);
+        setStatus({ status: 'loading' });
+        if (bridge.account.isConnected) {
+            try {
+                await bridge.disconnect();
+            }
+            catch (e) {
+                setWalletConnectingTo(null);
+                const err = new OpenfortError('Failed to disconnect', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                    error: e,
+                });
+                setStatus({ status: 'error', error: err });
+                onError({ hookOptions, error: err });
+                (_c = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _c === void 0 ? void 0 : _c.call(callbacks, err.message, err);
+                return;
+            }
+        }
+        try {
+            const result = await bridge.connectAsync({ connector });
+            const connectResult = result && typeof result === 'object' && 'accounts' in result
+                ? result
+                : undefined;
+            const addressFromResult = (_d = connectResult === null || connectResult === void 0 ? void 0 : connectResult.accounts) === null || _d === void 0 ? void 0 : _d[0];
+            await runConnectWithSiwe(bridge, openfort, {
+                address: addressFromResult,
+                connectorType: connector.type,
+                walletClientType: connector.id,
+                link,
+                onConnect: () => {
+                    var _a;
+                    setWalletConnectingTo(null);
+                    setStatus({ status: 'success' });
+                    onSuccess({ hookOptions, data: {} });
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onConnect) === null || _a === void 0 ? void 0 : _a.call(callbacks);
+                },
+                onError: (message, openfortError) => {
+                    var _a;
+                    setWalletConnectingTo(null);
+                    const err = openfortError !== null && openfortError !== void 0 ? openfortError : new OpenfortError(message, OpenfortReactErrorType.AUTHENTICATION_ERROR);
+                    setStatus({ status: 'error', error: err });
+                    onError({ hookOptions, error: err });
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _a === void 0 ? void 0 : _a.call(callbacks, message, err);
+                },
+            });
+        }
+        catch (err) {
+            setWalletConnectingTo(null);
+            const message = err instanceof Error ? err.message : 'Connection failed';
+            const openfortErr = new OpenfortError(message, OpenfortReactErrorType.AUTHENTICATION_ERROR, { error: err });
+            setStatus({ status: 'error', error: openfortErr });
+            onError({ hookOptions, error: openfortErr });
+            (_e = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onError) === null || _e === void 0 ? void 0 : _e.call(callbacks, message, openfortErr);
+        }
+    }, [bridge, openfort, hookOptions]);
+    const connectWallet = useCallback((connectorId, callbacks) => runConnectThenSiwe(connectorId, false, callbacks), [runConnectThenSiwe]);
+    const linkWallet = useCallback((connectorId, callbacks) => runConnectThenSiwe(connectorId, true, callbacks), [runConnectThenSiwe]);
+    return {
+        availableWallets,
+        connectWallet,
+        linkWallet,
+        walletConnectingTo,
+        ...mapStatus(status),
+    };
+}
+
+export { useWalletAuth };
+//# sourceMappingURL=useWalletAuth.js.map

package/build/wagmi/useWalletAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wallets/useExternalConnectors.d.ts

@@ -0,0 +1,17 @@
+import type { OpenfortEthereumBridgeConnector, OpenfortEthereumBridgeValue } from '../ethereum/OpenfortEthereumBridgeContext';
+import { type WalletConfigProps } from './walletConfigs';
+export type ExternalConnectorProps = {
+    id: string;
+    connector: OpenfortEthereumBridgeConnector;
+    isInstalled?: boolean;
+} & WalletConfigProps;
+type MapBridgeConnectorsOptions = {
+    walletConnectName?: string;
+};
+/** Maps bridge.connectors to ExternalConnectorProps[]. Used by EthereumBridgeStrategy and useExternalConnectors. */
+export declare function mapBridgeConnectorsToWalletProps(bridge: OpenfortEthereumBridgeValue, options?: MapBridgeConnectorsOptions): ExternalConnectorProps[];
+/** Returns the list of external connectors (MetaMask, WalletConnect, etc.) for the connect UI. Uses strategy when available; returns [] when embedded-only (no bridge). */
+export declare function useExternalConnectors(): ExternalConnectorProps[];
+/** Single connector by id. */
+export declare const useExternalConnector: (id: string) => ExternalConnectorProps | null;
+export {};

package/build/wallets/useExternalConnectors.js

@@ -0,0 +1,98 @@
+import { createElement } from 'react';
+import { useConnectionStrategy } from '../core/ConnectionStrategyContext.js';
+import { isCoinbaseWalletConnector, isInjectedConnector } from '../utils/index.js';
+import { walletConfigs } from './walletConfigs.js';
+
+/** Maps bridge.connectors to ExternalConnectorProps[]. Used by EthereumBridgeStrategy and useExternalConnectors. */
+function mapBridgeConnectorsToWalletProps(bridge, options = {}) {
+    const { walletConnectName } = options;
+    const wallets = bridge.connectors.map((connector) => {
+        var _a, _b, _c, _d;
+        let walletId = Object.keys(walletConfigs).find((id) => id
+            .split(',')
+            .map((i) => i.trim())
+            .indexOf(connector.id) !== -1);
+        // Fallback: when connector.id is 'injected', match by name for known wallets (e.g. MetaMask)
+        if (!walletId && connector.id === 'injected' && connector.name) {
+            const nameLower = connector.name.toLowerCase();
+            if (nameLower.includes('metamask')) {
+                walletId =
+                    (_a = Object.keys(walletConfigs).find((k) => { var _a; return ((_a = walletConfigs[k].name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'metamask'; })) !== null && _a !== void 0 ? _a : undefined;
+            }
+        }
+        const c = {
+            id: connector.id,
+            name: (_d = (_c = (_b = connector.name) !== null && _b !== void 0 ? _b : connector.id) !== null && _c !== void 0 ? _c : connector.type) !== null && _d !== void 0 ? _d : '',
+            icon: connector.icon
+                ? createElement('img', { src: connector.icon, alt: connector.name, width: '100%', height: '100%' })
+                : createElement('span', {
+                    style: {
+                        width: '100%',
+                        height: '100%',
+                        background: 'var(--ck-body-background)',
+                        borderRadius: 4,
+                    },
+                }),
+            connector,
+            iconShape: 'squircle',
+            isInstalled: connector.type === 'mock' || connector.type === 'injected' || isCoinbaseWalletConnector(connector.id),
+        };
+        if (walletId) {
+            const wallet = walletConfigs[walletId];
+            return {
+                ...c,
+                iconConnector: connector.icon
+                    ? createElement('img', { src: connector.icon, alt: connector.name, width: '100%', height: '100%' })
+                    : undefined,
+                ...wallet,
+            };
+        }
+        return c;
+    });
+    return wallets
+        .filter((wallet, index, self) => self.findIndex((w) => w.id === wallet.id) === index)
+        .map((wallet) => {
+        if (wallet.id === 'walletConnect') {
+            return {
+                ...wallet,
+                name: walletConnectName || wallet.name,
+                shortName: walletConnectName || wallet.shortName,
+            };
+        }
+        return wallet;
+    })
+        .sort((a, b) => {
+        const AisInstalled = a.isInstalled && isInjectedConnector(a.connector.type);
+        const BisInstalled = b.isInstalled && isInjectedConnector(b.connector.type);
+        if (AisInstalled && !BisInstalled)
+            return -1;
+        if (!AisInstalled && BisInstalled)
+            return 1;
+        return 0;
+    })
+        .sort((a, b) => {
+        if (a.id === 'walletConnect')
+            return 1;
+        if (b.id === 'walletConnect')
+            return -1;
+        return 0;
+    });
+}
+/** Returns the list of external connectors (MetaMask, WalletConnect, etc.) for the connect UI. Uses strategy when available; returns [] when embedded-only (no bridge). */
+function useExternalConnectors() {
+    const strategy = useConnectionStrategy();
+    if (!strategy)
+        return [];
+    return strategy.getConnectors();
+}
+/** Single connector by id. */
+const useExternalConnector = (id) => {
+    const connectors = useExternalConnectors();
+    const connector = connectors.find((c) => c.id === id);
+    if (!connector)
+        return null;
+    return connector;
+};
+
+export { mapBridgeConnectorsToWalletProps, useExternalConnector, useExternalConnectors };
+//# sourceMappingURL=useExternalConnectors.js.map

package/build/wallets/useExternalConnectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExternalConnectors.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/wallets/walletConfigs.js

@@ -0,0 +1,344 @@
+import { jsx } from 'react/jsx-runtime';
+import Logos from '../assets/logos.js';
+
+// Organised in alphabetical order by key
+const walletConfigs = {
+    mock: {
+        icon: jsx(Logos.Mock, {}),
+    },
+    argent: {
+        name: 'Argent',
+        icon: jsx(Logos.Argent, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/argent',
+            android: 'https://play.google.com/store/apps/details?id=im.argent.contractwalletclient',
+            ios: 'https://apps.apple.com/app/argent/id1358741926',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://argent.link/app/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    'coinbaseWallet, coinbaseWalletSDK': {
+        name: 'Coinbase Wallet',
+        shortName: 'Coinbase',
+        icon: jsx(Logos.Coinbase, { background: true }),
+        iconShape: 'squircle',
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/coinbasewallet',
+            website: 'https://www.coinbase.com/wallet/getting-started-extension',
+            android: 'https://play.google.com/store/apps/details?id=org.toshi',
+            ios: 'https://apps.apple.com/app/coinbase-wallet-store-crypto/id1278383455',
+            chrome: 'https://chrome.google.com/webstore/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://go.cb-w.com/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    'com.coinbase.wallet': {
+        name: 'Coinbase Wallet',
+        shortName: 'Coinbase',
+        icon: jsx(Logos.Coinbase, { background: true }),
+        iconShape: 'circle',
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/coinbasewallet',
+            website: 'https://www.coinbase.com/wallet/getting-started-extension',
+            android: 'https://play.google.com/store/apps/details?id=org.toshi',
+            ios: 'https://apps.apple.com/app/coinbase-wallet-store-crypto/id1278383455',
+            chrome: 'https://chrome.google.com/webstore/detail/coinbase-wallet-extension/hnfanknocfeofbddgcijnmhnfnkdnaad',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://go.cb-w.com/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    'com.crypto.wallet': {
+        name: 'Crypto.com',
+        shortName: 'Crypto',
+    },
+    dawn: {
+        name: 'Dawn Wallet',
+        shortName: 'Dawn',
+        downloadUrls: {
+            download: 'https://apps.apple.com/us/app/dawn-ethereum-wallet/id1673143782',
+            website: 'https://www.dawnwallet.xyz/',
+            ios: 'https://apps.apple.com/us/app/dawn-ethereum-wallet/id1673143782',
+        },
+    },
+    'co.family.wallet': {
+        name: 'Family',
+        shortName: 'Family',
+        icon: jsx(Logos.Family, {}),
+        iconShape: 'squircle',
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/family',
+            website: 'https://family.co',
+            ios: 'https://family.co/download',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `familywallet://wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    familyAccountsProvider: {
+        name: 'Family',
+        shortName: 'Family',
+        icon: jsx(Logos.FamilyAccount, {}),
+        iconConnector: jsx(Logos.FamilyAccount, {}),
+        iconShape: 'squircle',
+    },
+    frame: {
+        name: 'Frame',
+        icon: jsx(Logos.Frame, {}),
+        iconShouldShrink: true,
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/frame',
+            website: 'https://frame.sh',
+            chrome: 'https://chrome.google.com/webstore/detail/frame-companion/ldcoohedfbjoobcadoglnnmmfbdlmmhf',
+            firefox: 'https://addons.mozilla.org/en-US/firefox/addon/frame-extension',
+            brave: 'https://chrome.google.com/webstore/detail/frame-companion/ldcoohedfbjoobcadoglnnmmfbdlmmhf',
+        },
+        getWalletConnectDeeplink: (uri) => uri,
+    },
+    frontier: {
+        name: 'Frontier Wallet',
+        shortName: 'Frontier',
+        icon: jsx(Logos.Frontier, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/frontier',
+            ios: 'https://apps.apple.com/app/frontier-crypto-defi-wallet/id1482380988',
+            android: 'https://play.google.com/store/apps/details?id=com.frontierwallet',
+            website: 'https://frontier.xyz/',
+            chrome: 'https://chrome.google.com/webstore/detail/frontier-wallet/kppfdiipphfccemcignhifpjkapfbihd',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `frontier://wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    injected: {
+        name: 'Browser Wallet',
+        shortName: 'Browser',
+        icon: jsx(Logos.Injected, {}),
+    },
+    'metaMask, MetaMask, metaMask-io, io.metamask, io.metamask.mobile, metaMaskSDK': {
+        name: 'MetaMask',
+        icon: jsx(Logos.MetaMask, {}),
+        iconConnector: jsx(Logos.MetaMask, {}),
+        iconShouldShrink: true,
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/metamask',
+            website: 'https://metamask.io/download/',
+            android: 'https://play.google.com/store/apps/details?id=io.metamask',
+            ios: 'https://apps.apple.com/app/metamask/id1438144202',
+            chrome: 'https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn',
+            firefox: 'https://addons.mozilla.org/firefox/addon/ether-metamask/',
+            brave: 'https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn',
+            edge: 'https://microsoftedge.microsoft.com/addons/detail/metamask/ejbalbakoplchlghecdalmeeeajnimhm',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://metamask.app.link/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    'app.phantom': {
+        name: 'Phantom',
+        iconShape: 'squircle',
+    },
+    'me.rainbow': {
+        name: 'Rainbow Wallet',
+        shortName: 'Rainbow',
+        icon: jsx(Logos.Rainbow, {}),
+        iconShape: 'squircle',
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/rainbow',
+            website: 'https://rainbow.me/?utm_source=connectkit',
+            android: 'https://play.google.com/store/apps/details?id=me.rainbow&referrer=utm_source%3Dconnectkit&utm_source=connectkit',
+            ios: 'https://apps.apple.com/app/rainbow-ethereum-wallet/id1457119021?pt=119997837&ct=connectkit&mt=8',
+            chrome: 'https://rainbow.me/extension?utm_source=connectkit',
+            edge: 'https://rainbow.me/extension?utm_source=connectkit',
+            brave: 'https://rainbow.me/extension?utm_source=connectkit',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://rnbwapp.com/wc?uri=${encodeURIComponent(uri)}&connector=connectkit`;
+        },
+    },
+    'io.rabby': {
+        name: 'Rabby Wallet',
+        shortName: 'Rabby',
+        downloadUrls: {
+            website: 'https://rabby.io',
+            chrome: 'https://chrome.google.com/webstore/detail/rabby-wallet/acmacodkjbdgmoleebolmdjonilkdbch',
+        },
+    },
+    safe: {
+        name: 'Safe',
+        icon: jsx(Logos.Safe, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/safe',
+            website: 'https://safe.global/',
+            ios: 'https://apps.apple.com/app/id1515759131',
+            android: 'https://play.google.com/store/apps/details?id=io.gnosis.safe',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://gnosis-safe.io/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    'xyz.talisman': {
+        name: 'Talisman',
+        shortName: 'Talisman',
+        iconShape: 'squircle',
+        downloadUrls: {
+            download: 'https://talisman.xyz/download',
+            website: 'https://talisman.xyz',
+            chrome: 'https://chrome.google.com/webstore/detail/talisman-polkadot-wallet/fijngjgcjhjmmpcmkeiomlglpeiijkld',
+            firefox: 'https://addons.mozilla.org/en-US/firefox/addon/talisman-wallet-extension/',
+        },
+    },
+    'com.trustwallet.app': {
+        name: 'Trust Wallet',
+        shortName: 'Trust',
+        icon: jsx(Logos.Trust, {}),
+        iconShouldShrink: true,
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/trust',
+            android: 'https://play.google.com/store/apps/details?id=com.wallet.crypto.trustapp',
+            ios: 'https://apps.apple.com/app/trust-crypto-bitcoin-wallet/id1288339409',
+        },
+        getWalletConnectDeeplink(uri) {
+            return `https://link.trustwallet.com/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    infinityWallet: {
+        name: 'Infinity Wallet',
+        icon: jsx(Logos.InfinityWallet, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/infinityWallet',
+            website: 'https://infinitywallet.io/download',
+            chrome: 'https://infinitywallet.io/download',
+            firefox: 'https://infinitywallet.io/download',
+            brave: 'https://infinitywallet.io/download',
+            edge: 'https://infinitywallet.io/download',
+        },
+    },
+    imToken: {
+        name: 'imToken',
+        icon: jsx(Logos.ImToken, {}),
+        downloadUrls: {
+            //website: 'https://support.token.im/hc/en-us/categories/360000925393',
+            download: 'https://connect.family.co/v0/download/imToken',
+            android: 'https://play.google.com/store/apps/details?id=im.token.app',
+            ios: 'https://itunes.apple.com/us/app/imtoken2/id1384798940',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `imtokenv2://wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    unstoppable: {
+        name: 'Unstoppable',
+        icon: jsx(Logos.Unstoppable, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/unstoppable',
+            ios: 'https://apps.apple.com/app/bank-bitcoin-wallet/id1447619907',
+            android: 'https://play.google.com/store/apps/details?id=io.horizontalsystems.bankwallet',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://unstoppable.money/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    onto: {
+        name: 'ONTO',
+        icon: jsx(Logos.ONTO, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/onto',
+            ios: 'https://apps.apple.com/app/onto-an-ontology-dapp/id1436009823',
+            android: 'https://play.google.com/store/apps/details?id=com.github.ontio.onto',
+            website: 'https://onto.app/en/download/',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://onto.app/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    steak: {
+        name: 'Steak',
+        icon: jsx(Logos.Steak, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/steak',
+            android: 'https://play.google.com/store/apps/details?id=fi.steakwallet.app',
+            ios: 'https://apps.apple.com/app/steakwallet/id1569375204',
+            website: 'https://steakwallet.fi/download',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://links.steakwallet.fi/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    ledger: {
+        name: 'Ledger Live',
+        shortName: 'Ledger',
+        icon: jsx(Logos.Ledger, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/ledger',
+            website: 'https://www.ledger.com/ledger-live/download#download-device-2',
+            android: 'https://play.google.com/store/apps/details?id=com.ledger.live',
+            ios: 'https://apps.apple.com/app/ledger-live-web3-wallet/id1361671700',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `ledgerlive://wc?uri=${encodeURIComponent(uri)}`;
+        },
+        shouldDeeplinkDesktop: true,
+    },
+    zerion: {
+        name: 'Zerion',
+        icon: jsx(Logos.Zerion, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/zerion',
+            ios: 'https://apps.apple.com/app/apple-store/id1456732565',
+            android: 'https://play.google.com/store/apps/details?id=io.zerion.android',
+            website: 'https://zerion.io/',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://app.zerion.io/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    slope: {
+        name: 'Slope',
+        icon: jsx(Logos.Slope, {}),
+        downloadUrls: {
+            download: 'https://connect.family.co/v0/download/slope',
+            ios: 'https://apps.apple.com/app/slope-wallet/id1574624530',
+            android: 'https://play.google.com/store/apps/details?id=com.wd.wallet',
+            chrome: 'https://chrome.google.com/webstore/detail/slope-wallet/pocmplpaccanhmnllbbkpgfliimjljgo',
+            website: 'https://slope.finance/',
+        },
+        getWalletConnectDeeplink: (uri) => {
+            return `https://slope.finance/app/wc?uri=${encodeURIComponent(uri)}`;
+        },
+    },
+    tokenPocket: {
+        name: 'TokenPocket Wallet',
+        icon: jsx(Logos.TokenPocket, {}),
+        downloadUrls: {
+            website: 'https://www.tokenpocket.pro/en/download/app',
+            download: 'https://www.tokenpocket.pro/en/download/app',
+            android: 'https://play.google.com/store/apps/details?id=vip.mytokenpocket',
+            ios: 'https://apps.apple.com/us/app/tp-global-wallet/id6444625622',
+            chrome: 'https://chrome.google.com/webstore/detail/tokenpocket/mfgccjchihfkkindfppnaooecgfneiii',
+        },
+    },
+    talisman: {
+        name: 'Talisman',
+        icon: jsx(Logos.Talisman, {}),
+        downloadUrls: {
+            download: 'https://talisman.xyz/download',
+            website: 'https://talisman.xyz',
+            chrome: 'https://chrome.google.com/webstore/detail/talisman-polkadot-wallet/fijngjgcjhjmmpcmkeiomlglpeiijkld',
+            firefox: 'https://addons.mozilla.org/en-US/firefox/addon/talisman-wallet-extension/',
+        },
+    },
+    walletConnect: {
+        name: 'Other Wallets',
+        shortName: 'Other',
+        icon: jsx(Logos.WalletConnect, { background: true }),
+        iconConnector: jsx(Logos.OtherWallets, {}),
+        iconShape: 'square',
+        getWalletConnectDeeplink: (uri) => uri,
+    },
+};
+
+export { walletConfigs };
+//# sourceMappingURL=walletConfigs.js.map

package/build/wallets/walletConfigs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletConfigs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}