@openfort/react 0.3.2 → 1.0.1

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';

package/build/core/strategies/EthereumBridgeStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { OpenfortEthereumBridgeValue } from '../../ethereum/OpenfortEthereumBridgeContext';
+import type { ExternalConnectorProps } from '../../wallets/useExternalConnectors';
+import type { ConnectionStrategy } from '../ConnectionStrategy';
+/**
+ * Creates the EVM strategy when wagmi bridge is present.
+ * Delegates to bridge for account, chain, connectors, and switchChain.
+ *
+ * @param bridge - Wagmi bridge context value
+ * @param connectors - Mapped connector props for the UI
+ */
+export declare function createEthereumBridgeStrategy(bridge: OpenfortEthereumBridgeValue, connectors: ExternalConnectorProps[]): ConnectionStrategy;

package/build/core/strategies/EthereumBridgeStrategy.js

@@ -0,0 +1,83 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { logger } from '../../utils/logger.js';
+import { resolveEthereumFeeSponsorship } from '../strategyUtils.js';
+
+/**
+ * Creates the EVM strategy when wagmi bridge is present.
+ * Delegates to bridge for account, chain, connectors, and switchChain.
+ *
+ * @param bridge - Wagmi bridge context value
+ * @param connectors - Mapped connector props for the UI
+ */
+function createEthereumBridgeStrategy(bridge, connectors) {
+    // Closure-level: survives strategy recreation via useMemo but is instance-scoped.
+    // Module-level vars would leak across multiple CoreOpenfortProvider instances (e.g. tests).
+    let lastInitChainId;
+    return {
+        kind: 'bridge',
+        chainType: ChainTypeEnum.EVM,
+        isConnected(state) {
+            return !!(bridge.account.isConnected && bridge.account.address && state.user);
+        },
+        getChainId() {
+            return bridge.chainId;
+        },
+        getAddress() {
+            var _a;
+            return (_a = bridge.account.address) !== null && _a !== void 0 ? _a : undefined;
+        },
+        getConnectRoutes() {
+            return ['embedded', 'external-wallets'];
+        },
+        getConnectors() {
+            return connectors;
+        },
+        async initProvider(openfort, walletConfig, chainIdOverride) {
+            const chainId = chainIdOverride !== null && chainIdOverride !== void 0 ? chainIdOverride : bridge.chainId;
+            const feeSponsorshipObj = chainId != null ? resolveEthereumFeeSponsorship(walletConfig, chainId) : undefined;
+            const rpcUrls = bridge.config.chains.reduce((acc, ch) => {
+                var _a;
+                const url = (_a = bridge.config.getClient({ chainId: ch.id }).transport) === null || _a === void 0 ? void 0 : _a.url;
+                if (url)
+                    acc[ch.id] = url;
+                return acc;
+            }, {});
+            const provider = await openfort.embeddedWallet.getEthereumProvider({
+                ...feeSponsorshipObj,
+                chains: rpcUrls,
+                announceProvider: true,
+                providerInfo: {
+                    name: 'Openfort',
+                    rdns: 'xyz.openfort',
+                    icon: 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"/>',
+                },
+            });
+            // Tell the provider which chain is active (EIP-1193). Keeps provider in sync with wagmi.
+            // Skip if the chain hasn't changed since last init to avoid spurious 422s.
+            // Also skip if there are no accounts yet — switch-chain requires an initialized account.
+            if (chainId != null && chainId !== lastInitChainId) {
+                const accounts = (await provider.request({ method: 'eth_accounts' }));
+                if (accounts.length > 0) {
+                    try {
+                        await provider.request({
+                            method: 'wallet_switchEthereumChain',
+                            params: [{ chainId: `0x${chainId.toString(16)}` }],
+                        });
+                        lastInitChainId = chainId;
+                    }
+                    catch (switchErr) {
+                        logger.warn('[@openfort/react] wallet_switchEthereumChain failed — provider may be on wrong chain', switchErr);
+                    }
+                }
+            }
+        },
+        async disconnect(openfort) {
+            lastInitChainId = undefined;
+            await bridge.disconnect();
+            await openfort.auth.logout();
+        },
+    };
+}
+
+export { createEthereumBridgeStrategy };
+//# sourceMappingURL=EthereumBridgeStrategy.js.map

package/build/core/strategies/EthereumBridgeStrategy.js.map

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

package/build/core/strategies/EthereumEmbeddedStrategy.d.ts

@@ -0,0 +1,8 @@
+import type { OpenfortWalletConfig } from '../../components/Openfort/types';
+import type { ConnectionStrategy } from '../ConnectionStrategy';
+/**
+ * Creates the EVM embedded strategy for SDK-only mode (no wagmi).
+ *
+ * @param walletConfig - Wallet config with ethereum.chainId and rpcUrls
+ */
+export declare function createEthereumEmbeddedStrategy(walletConfig: OpenfortWalletConfig | undefined): ConnectionStrategy;