@openfort/react 0.3.1 → 1.0.0

package/build/components/Pages/SolanaWallets/index.js

@@ -0,0 +1,36 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { PlusIcon } from '../../../assets/icons.js';
+import { toSolanaUserWallet } from '../../../hooks/openfort/walletTypes.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import Button from '../../Common/Button/index.js';
+import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
+import { WalletRecoveryIcon } from '../../Common/WalletRecoveryIcon/index.js';
+import { recoverRoute } from '../../Openfort/routeHelpers.js';
+import { routes } from '../../Openfort/types.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { PageContent } from '../../PageContent/index.js';
+import { ProvidersButton, ProviderIcon, ProviderLabel } from '../Providers/styles.js';
+
+function WalletRow({ wallet }) {
+    const { setRoute } = useOpenfort();
+    const { chainType } = useOpenfortCore();
+    const display = wallet.address.length > 12 ? `${wallet.address.slice(0, 4)}...${wallet.address.slice(-4)}` : wallet.address;
+    const handleClick = () => {
+        const walletForRoute = toSolanaUserWallet(wallet);
+        setRoute(recoverRoute(chainType, walletForRoute));
+    };
+    return (jsx(ProvidersButton, { children: jsxs(Button, { onClick: handleClick, children: [jsx(ProviderLabel, { children: display }), jsx(ProviderIcon, { children: jsx(WalletRecoveryIcon, { recovery: wallet.recoveryMethod }) })] }) }));
+}
+function SolanaWallets() {
+    var _a;
+    const { setRoute } = useOpenfort();
+    const embeddedWallet = useSolanaEmbeddedWallet();
+    const wallets = (_a = embeddedWallet.wallets) !== null && _a !== void 0 ? _a : [];
+    const solanaWallets = wallets.filter((w) => w.chainType === ChainTypeEnum.SVM);
+    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Solana Wallets" }), jsxs(ModalBody, { children: [solanaWallets.map((wallet) => (jsx(WalletRow, { wallet: wallet }, wallet.id))), jsx(ProvidersButton, { children: jsx(Button, { onClick: () => setRoute(routes.SOL_CREATE_WALLET), icon: jsx(ProviderIcon, { children: jsx(PlusIcon, {}) }), children: jsx(ProviderLabel, { children: "Create new wallet" }) }) })] })] }));
+}
+
+export { SolanaWallets as default };
+//# sourceMappingURL=index.js.map

package/build/components/Pages/SolanaWallets/index.js.map

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

package/build/components/PasswordStrength/PasswordStrengthIndicator.js

@@ -0,0 +1,62 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { motion } from 'framer-motion';
+import { useMemo } from 'react';
+import styled from '../../styles/styled/index.js';
+import { getPasswordStrength, getPasswordStrengthLabel } from './password-utility.js';
+
+const Container = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  margin-top: 0.5rem;
+  margin-bottom: 0.5rem;
+  text-align: left;
+`;
+const BarWrapper = styled.div `
+  width: 100%;
+  height: 4px;
+  background: var(--ck-secondary-button-background);
+  border-radius: 4px;
+  overflow: hidden;
+`;
+const Progress = styled(motion.div) `
+  height: 100%;
+  background: ${({ color }) => color};
+  border-radius: 4px;
+`;
+const Label = styled.div `
+  font-size: 0.875rem;
+  font-weight: 500;
+  color: var(--ck-body-color-muted);
+`;
+const LabelColor = styled.span `
+  color: ${({ color }) => color};
+`;
+const PasswordStrengthIndicator = ({ password, showPasswordIsTooWeakError, }) => {
+    const passwordStrength = getPasswordStrength(password); // should return a number between 0 and 1
+    const label = getPasswordStrengthLabel(passwordStrength);
+    const color = useMemo(() => {
+        switch (label) {
+            case 'Weak':
+                return '#ef4444'; // red-500
+            case 'Medium':
+                return '#f59e0b'; // amber-500
+            case 'Strong':
+                return '#10b981'; // emerald-500
+            case 'Very Strong':
+                return '#3b82f6'; // blue-500
+            default:
+                return '#d1d5db'; // gray-300
+        }
+    }, [label]);
+    return (jsxs(Container, { children: [jsx(BarWrapper, { children: jsx(Progress, { color: color, initial: { width: 0 }, animate: { width: `${passwordStrength * 100}%` }, transition: { ease: 'easeOut', duration: 0.5 } }) }), jsxs("div", { style: { position: 'relative' }, children: [jsx(motion.div, { initial: { opacity: 1 }, animate: {
+                            opacity: showPasswordIsTooWeakError ? 0 : 1,
+                            y: showPasswordIsTooWeakError ? 5 : 0,
+                        }, transition: { duration: 0.3 }, children: jsxs(Label, { children: ["Password strength: ", jsx(LabelColor, { color: color, children: label })] }) }), jsx(motion.div, { initial: { opacity: 0 }, animate: {
+                            opacity: showPasswordIsTooWeakError ? 1 : 0,
+                            y: showPasswordIsTooWeakError ? 0 : -5,
+                        }, transition: { duration: 0.3 }, style: { color: '#ef4444', fontSize: '0.875rem', fontWeight: 500, position: 'absolute', top: '0' }, children: "Password is too weak" })] })] }));
+};
+
+export { PasswordStrengthIndicator };
+//# sourceMappingURL=PasswordStrengthIndicator.js.map

package/build/components/PasswordStrength/PasswordStrengthIndicator.js.map

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

package/build/components/PasswordStrength/password-utility.js

@@ -0,0 +1,128 @@
+import calculateEntropy from 'fast-password-entropy';
+
+/**
+ * Password utility helpers for strength calculation and validation.
+ *
+ * Provides functions for password strength calculation, passphrase generation, and password validation.
+ */
+/**
+ * Regular expression to match lowercase letters.
+ */
+const LOWERCASE_REGEX = /[a-z]/;
+/**
+ * Regular expression to match uppercase letters.
+ */
+const UPPERCASE_REGEX = /[A-Z]/;
+/**
+ * Regular expression to match digits.
+ */
+const DIGIT_REGEX = /[0-9]/;
+/**
+ * Special characters allowed in passwords.
+ */
+const SPECIAL_CHARACTERS = '!@#$%^&()\\-*+.';
+/**
+ * Escape regex metacharacters for safe use inside a character class.
+ */
+function escapeForCharClass(str) {
+    return str.replace(/[-\\^]/g, '\\$&');
+    // escapes -, \, and ^ (the only risky chars in [])
+}
+/**
+ * Regular expression to match special characters.
+ */
+const SPECIAL_CHARACTER_REGEX = new RegExp(`[${escapeForCharClass(SPECIAL_CHARACTERS)}]`);
+/**
+ * Maximum entropy score for normalization.
+ */
+const MAX_ENTROPY_SCORE = 95;
+/**
+ * Minimum password length for security.
+ */
+const MIN_PASSWORD_LENGTH = 8;
+/**
+ * Weight for diversity score in overall strength calculation.
+ */
+const DIVERSITY_WEIGHT = 0.3;
+const ENTROPY_WEIGHT = 0.7;
+const MEDIUM_SCORE_THRESHOLD = 0.5;
+const STRONG_SCORE_THRESHOLD = 0.75;
+const VERY_STRONG_SCORE_THRESHOLD = 0.9;
+/**
+ * Converts a numeric password strength score to a human-readable label.
+ *
+ * @param score - The strength score (0-1).
+ * @returns The corresponding strength label.
+ *
+ * @example
+ * ```ts
+ * const label = getPasswordStrengthLabel(0.8);
+ * // label === 'Strong'
+ * ```
+ */
+function getPasswordStrengthLabel(score) {
+    if (score > VERY_STRONG_SCORE_THRESHOLD) {
+        return 'Very Strong';
+    }
+    else if (score > STRONG_SCORE_THRESHOLD) {
+        return 'Strong';
+    }
+    else if (score > MEDIUM_SCORE_THRESHOLD) {
+        return 'Medium';
+    }
+    else {
+        return 'Weak';
+    }
+}
+/**
+ * Calculates the diversity score of a password based on character types used.
+ *
+ * Considers lowercase, uppercase, digits, and special characters.
+ *
+ * @param password - The password to analyse.
+ * @returns A score between 0 and 1 representing character diversity.
+ *
+ * @example
+ * ```ts
+ * const diversity = calculatePasswordDiversityScore('Password123!');
+ * ```
+ */
+function calculatePasswordDiversityScore(password) {
+    // Passwords shorter than minimum length get a score of 0
+    if (password.length < MIN_PASSWORD_LENGTH) {
+        return 0;
+    }
+    let characterTypesUsed = 0;
+    if (LOWERCASE_REGEX.test(password)) {
+        characterTypesUsed += 1;
+    }
+    if (UPPERCASE_REGEX.test(password)) {
+        characterTypesUsed += 1;
+    }
+    if (DIGIT_REGEX.test(password)) {
+        characterTypesUsed += 1;
+    }
+    if (SPECIAL_CHARACTER_REGEX.test(password)) {
+        characterTypesUsed += 1;
+    }
+    return Math.max(0, Math.min(1, characterTypesUsed / 4));
+}
+/**
+ * Calculates the overall password strength combining diversity and entropy.
+ *
+ * @param password - The password to analyse.
+ * @returns A strength score between 0 and 1.
+ *
+ * @example
+ * ```ts
+ * const strength = getPasswordStrength('Password123!');
+ * ```
+ */
+function getPasswordStrength(password = '') {
+    const diversityScore = calculatePasswordDiversityScore(password);
+    const entropyScore = calculateEntropy(password) / MAX_ENTROPY_SCORE;
+    return Math.min(diversityScore * DIVERSITY_WEIGHT + entropyScore * ENTROPY_WEIGHT, 1);
+}
+
+export { MEDIUM_SCORE_THRESHOLD, getPasswordStrength, getPasswordStrengthLabel };
+//# sourceMappingURL=password-utility.js.map

package/build/components/PasswordStrength/password-utility.js.map

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

package/build/constants/chainConfigs.js

@@ -0,0 +1,316 @@
+import { jsx } from 'react/jsx-runtime';
+import ChainIcons from '../assets/chains.js';
+
+// Note: these rpcUrls are incomplete, and are subject to change from their respective providers
+// More RPC URLs can be found: https://chainid.network/chains.json
+const chainConfigs = [
+    {
+        id: 1,
+        name: 'Ethereum',
+        logo: jsx(ChainIcons.Ethereum, {}),
+        rpcUrls: {
+            alchemy: {
+                http: ['https://eth-mainnet.g.alchemy.com/v2'],
+                webSocket: ['wss://eth-mainnet.g.alchemy.com/v2'],
+            },
+            infura: {
+                http: ['https://mainnet.infura.io/v3'],
+                webSocket: ['wss://mainnet.infura.io/ws/v3'],
+            },
+        },
+    },
+    {
+        id: 232,
+        name: 'Lens Chain',
+        logo: jsx(ChainIcons.LensChain, {}),
+    },
+    {
+        id: 37111,
+        name: 'Lens Chain Testnet',
+        logo: jsx(ChainIcons.LensChain, { testnet: true }),
+    },
+    {
+        id: 3,
+        name: 'Rinkeby',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        rpcUrls: {},
+    },
+    {
+        id: 4,
+        name: 'Ropsten',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+    },
+    {
+        id: 5,
+        name: 'Görli',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+    },
+    {
+        id: 42,
+        name: 'Kovan',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+    },
+    {
+        id: 10,
+        name: 'Optimism',
+        logo: jsx(ChainIcons.Optimism, {}),
+    },
+    {
+        id: 69, // nice
+        name: 'Optimism Kovan',
+        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+    },
+    {
+        id: 420, // nice
+        name: 'Optimism Goerli',
+        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+    },
+    {
+        id: 11155420,
+        name: 'Optimism Sepolia',
+        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+    },
+    {
+        id: 137,
+        name: 'Polygon',
+        logo: jsx(ChainIcons.Polygon, {}),
+    },
+    {
+        id: 80001,
+        name: 'Polygon Mumbai',
+        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+    },
+    {
+        id: 80002,
+        name: 'Polygon Amoy',
+        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+    },
+    {
+        id: 13337,
+        name: 'Beam Testnet',
+        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+    },
+    {
+        id: 31337,
+        name: 'Hardhat',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+    },
+    {
+        id: 1337,
+        name: 'Localhost',
+        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+    },
+    {
+        id: 42161,
+        name: 'Arbitrum',
+        logo: jsx(ChainIcons.Arbitrum, {}),
+        rpcUrls: {
+            alchemy: {
+                http: ['https://arb-mainnet.g.alchemy.com/v2'],
+                webSocket: ['wss://arb-mainnet.g.alchemy.com/v2'],
+            },
+            infura: {
+                http: ['https://arbitrum-mainnet.infura.io/v3'],
+                webSocket: ['wss://arbitrum-mainnet.infura.io/ws/v3'],
+            },
+        },
+    },
+    {
+        id: 421611,
+        name: 'Arbitrum Rinkeby',
+        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+    },
+    {
+        id: 421613,
+        name: 'Arbitrum Goerli',
+        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+        rpcUrls: {
+            alchemy: {
+                http: ['https://arb-goerli.g.alchemy.com/v2'],
+                webSocket: ['wss://arb-goerli.g.alchemy.com/v2'],
+            },
+            infura: {
+                http: ['https://arbitrum-goerli.infura.io/v3'],
+                webSocket: ['wss://arbitrum-goerli.infura.io/ws/v3'],
+            },
+        },
+    },
+    {
+        id: 40,
+        name: 'Telos',
+        logo: jsx(ChainIcons.Telos, {}),
+    },
+    {
+        id: 41,
+        name: 'Telos Testnet',
+        logo: jsx(ChainIcons.Telos, { testnet: true }),
+    },
+    {
+        id: 1313161554,
+        name: 'Aurora',
+        logo: jsx(ChainIcons.Aurora, {}),
+    },
+    {
+        id: 1313161555,
+        name: 'Aurora Testnet',
+        logo: jsx(ChainIcons.Aurora, { testnet: true }),
+    },
+    {
+        id: 43114,
+        name: 'Avalanche',
+        logo: jsx(ChainIcons.Avalanche, {}),
+    },
+    {
+        id: 43113,
+        name: 'Avalanche Fuji',
+        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+    },
+    {
+        id: 31337,
+        name: 'Foundry',
+        logo: jsx(ChainIcons.Foundry, { testnet: true }),
+    },
+    {
+        id: 100,
+        name: 'Gnosis',
+        logo: jsx(ChainIcons.Gnosis, {}),
+    },
+    {
+        id: 9001,
+        name: 'Evmos',
+        logo: jsx(ChainIcons.Evmos, {}),
+    },
+    {
+        id: 9000,
+        name: 'Evmos Testnet',
+        logo: jsx(ChainIcons.Evmos, { testnet: true }),
+    },
+    {
+        id: 56,
+        name: 'BNB Smart Chain',
+        logo: jsx(ChainIcons.BinanceSmartChain, {}),
+    },
+    {
+        id: 97,
+        name: 'Binance Smart Chain Testnet',
+        logo: jsx(ChainIcons.BinanceSmartChain, { testnet: true }),
+    },
+    {
+        id: 11155111,
+        name: 'Sepolia',
+        logo: jsx(ChainIcons.Sepolia, {}),
+    },
+    {
+        id: 841,
+        name: 'Taraxa',
+        logo: jsx(ChainIcons.Taraxa, {}),
+    },
+    {
+        id: 842,
+        name: 'Taraxa Testnet',
+        logo: jsx(ChainIcons.Taraxa, { testnet: true }),
+    },
+    {
+        id: 324,
+        name: 'zkSync',
+        logo: jsx(ChainIcons.zkSync, {}),
+    },
+    {
+        id: 280,
+        name: 'zkSync Testnet',
+        logo: jsx(ChainIcons.zkSync, { testnet: true }),
+    },
+    {
+        id: 42220,
+        name: 'Celo',
+        logo: jsx(ChainIcons.Celo, {}),
+    },
+    {
+        id: 44787,
+        name: 'Celo Alfajores',
+        logo: jsx(ChainIcons.Celo, { testnet: true }),
+    },
+    {
+        id: 7700,
+        name: 'Canto',
+        logo: jsx(ChainIcons.Canto, {}),
+    },
+    {
+        id: 14,
+        name: 'Flare',
+        logo: jsx(ChainIcons.Flare, {}),
+    },
+    {
+        id: 114,
+        name: 'Coston2',
+        logo: jsx(ChainIcons.Flare, {}),
+    },
+    {
+        id: 314,
+        name: 'Filecoin',
+        logo: jsx(ChainIcons.Filecoin, {}),
+    },
+    {
+        id: 3141,
+        name: 'Filecoin Hyperspace',
+        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+    },
+    {
+        id: 314159,
+        name: 'Filecoin Calibration',
+        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+    },
+    {
+        id: 1088,
+        name: 'Metis',
+        logo: jsx(ChainIcons.Metis, {}),
+    },
+    {
+        id: 599,
+        name: 'Metis Goerli',
+        logo: jsx(ChainIcons.Metis, { testnet: true }),
+    },
+    {
+        id: 4689,
+        name: 'IoTeX',
+        logo: jsx(ChainIcons.IoTeX, {}),
+    },
+    {
+        id: 4690,
+        name: 'IoTeX Testnet',
+        logo: jsx(ChainIcons.IoTeX, { testnet: true }),
+    },
+    {
+        id: 8453,
+        name: 'Base',
+        logo: jsx(ChainIcons.Base, {}),
+    },
+    {
+        id: 84531,
+        name: 'Base Goerli',
+        logo: jsx(ChainIcons.Base, { testnet: true }),
+    },
+    {
+        id: 84532,
+        name: 'Base Sepolia',
+        logo: jsx(ChainIcons.Base, { testnet: true }),
+    },
+    {
+        id: 7777777,
+        name: 'Zora',
+        logo: jsx(ChainIcons.Zora, {}),
+    },
+    {
+        id: 999999999,
+        name: 'Zora Sepolia',
+        logo: jsx(ChainIcons.Zora, { testnet: true }),
+    },
+    {
+        id: 999,
+        name: 'Zora Goerli Testnet',
+        logo: jsx(ChainIcons.Zora, { testnet: true }),
+    },
+];
+
+export { chainConfigs };
+//# sourceMappingURL=chainConfigs.js.map

package/build/constants/chainConfigs.js.map

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

package/build/constants/defaultTheme.js

@@ -0,0 +1,6 @@
+var defaultTheme = {
+    mobileWidth: 560,
+};
+
+export { defaultTheme as default };
+//# sourceMappingURL=defaultTheme.js.map

package/build/constants/defaultTheme.js.map

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

package/build/constants/openfort.d.ts

@@ -1 +1,5 @@
+/**
+ * Identifier for the Openfort embedded wallet connector.
+ * Used when identifying the embedded wallet in connector lists.
+ */
 export declare const embeddedWalletId = "xyz.openfort";

package/build/constants/openfort.js

@@ -0,0 +1,8 @@
+/**
+ * Identifier for the Openfort embedded wallet connector.
+ * Used when identifying the embedded wallet in connector lists.
+ */
+const embeddedWalletId = 'xyz.openfort';
+
+export { embeddedWalletId };
+//# sourceMappingURL=openfort.js.map

package/build/constants/openfort.js.map

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

package/build/core/ConnectionStrategy.d.ts

@@ -0,0 +1,31 @@
+import type { ChainTypeEnum, EmbeddedAccount, EmbeddedState, Openfort, User } from '@openfort/openfort-js';
+import type { OpenfortWalletConfig } from '../components/Openfort/types';
+import type { ExternalConnectorProps } from '../wallets/useExternalConnectors';
+/** Default chain when EVM without Wagmi and walletConfig.ethereum.chainId is missing. Sepolia. */
+export declare const DEFAULT_DEV_CHAIN_ID: 11155111;
+/** Default testnet chain for balance/hooks when no chain context. Base Sepolia. */
+export declare const DEFAULT_TESTNET_CHAIN_ID: 84532;
+export interface ConnectionStrategyState {
+    user: User | null;
+    embeddedAccounts: EmbeddedAccount[] | undefined;
+    /** When set, strategy uses this as the connected address (e.g. after user switches active embedded wallet). */
+    activeEmbeddedAddress?: string | null;
+    chainType: ChainTypeEnum;
+    /** For Solana embedded: only treat as connected when READY (wallet actually recovered). */
+    embeddedState?: EmbeddedState;
+}
+export type ConnectRoute = 'embedded' | 'external-wallets';
+export interface ConnectionStrategy {
+    readonly kind: 'bridge' | 'embedded';
+    readonly chainType: ChainTypeEnum;
+    isConnected(state: ConnectionStrategyState): boolean;
+    getChainId(): number | undefined;
+    getAddress(state: ConnectionStrategyState): string | undefined;
+    /** When 'external-wallets', ConnectModal may show Connectors page; when 'embedded' only, skip to providers. */
+    getConnectRoutes(): ConnectRoute[];
+    /** External wallet connectors; only when wagmi/bridge exists. Otherwise []. */
+    getConnectors(): ExternalConnectorProps[];
+    /** @param chainId - Current chain for EVM; when provided, uses this for fee sponsorship/rpc instead of config default. */
+    initProvider(openfort: Openfort, walletConfig: OpenfortWalletConfig, chainId?: number): Promise<void>;
+    disconnect(openfort: Openfort): Promise<void>;
+}

package/build/core/ConnectionStrategy.js

@@ -0,0 +1,9 @@
+import { sepolia, baseSepolia } from 'viem/chains';
+
+/** Default chain when EVM without Wagmi and walletConfig.ethereum.chainId is missing. Sepolia. */
+const DEFAULT_DEV_CHAIN_ID = sepolia.id;
+/** Default testnet chain for balance/hooks when no chain context. Base Sepolia. */
+const DEFAULT_TESTNET_CHAIN_ID = baseSepolia.id;
+
+export { DEFAULT_DEV_CHAIN_ID, DEFAULT_TESTNET_CHAIN_ID };
+//# sourceMappingURL=ConnectionStrategy.js.map

package/build/core/ConnectionStrategy.js.map

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

package/build/core/ConnectionStrategyContext.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import type { ConnectionStrategy } from './ConnectionStrategy';
+/**
+ * Provides the current connection strategy (bridge or embedded) to the tree.
+ * Used internally by OpenfortProvider. Rarely needed in app code.
+ */
+export declare function ConnectionStrategyProvider({ strategy, children, }: {
+    strategy: ConnectionStrategy | null;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Returns the current connection strategy (bridge or embedded), or null if not in provider.
+ *
+ * @returns ConnectionStrategy or null
+ */
+export declare function useConnectionStrategy(): ConnectionStrategy | null;

package/build/core/ConnectionStrategyContext.js

@@ -0,0 +1,22 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext } from 'react';
+
+const ConnectionStrategyContext = createContext(null);
+/**
+ * Provides the current connection strategy (bridge or embedded) to the tree.
+ * Used internally by OpenfortProvider. Rarely needed in app code.
+ */
+function ConnectionStrategyProvider({ strategy, children, }) {
+    return jsx(ConnectionStrategyContext.Provider, { value: strategy, children: children });
+}
+/**
+ * Returns the current connection strategy (bridge or embedded), or null if not in provider.
+ *
+ * @returns ConnectionStrategy or null
+ */
+function useConnectionStrategy() {
+    return useContext(ConnectionStrategyContext);
+}
+
+export { ConnectionStrategyProvider, useConnectionStrategy };
+//# sourceMappingURL=ConnectionStrategyContext.js.map

package/build/core/ConnectionStrategyContext.js.map

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

package/build/core/errors.d.ts

@@ -0,0 +1 @@
+export { OpenfortError, OpenfortReactErrorType } from '../types';