@openfort/react 0.3.2 → 1.0.0

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;

package/build/core/strategies/EthereumEmbeddedStrategy.js

@@ -0,0 +1,85 @@
+import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { logger } from '../../utils/logger.js';
+import { DEFAULT_DEV_CHAIN_ID } from '../ConnectionStrategy.js';
+import { firstEmbeddedAddress, resolveEthereumFeeSponsorship } from '../strategyUtils.js';
+
+function hasEmbeddedEthereum(state) {
+    var _a, _b;
+    if (!state.user || !state.activeEmbeddedAddress || state.embeddedState !== EmbeddedState.READY)
+        return false;
+    return ((_b = (_a = state.embeddedAccounts) === null || _a === void 0 ? void 0 : _a.some((a) => a.chainType === ChainTypeEnum.EVM && a.address === state.activeEmbeddedAddress)) !== null && _b !== void 0 ? _b : false);
+}
+/**
+ * Creates the EVM embedded strategy for SDK-only mode (no wagmi).
+ *
+ * @param walletConfig - Wallet config with ethereum.chainId and rpcUrls
+ */
+function createEthereumEmbeddedStrategy(walletConfig) {
+    var _a;
+    // 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;
+    const chainId = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.chainId;
+    const effectiveChainId = chainId !== null && chainId !== void 0 ? chainId : (() => {
+        logger.warn('[@openfort/react] EVM without Wagmi: no walletConfig.ethereum.chainId. Using development chain default (Sepolia). Set walletConfig.ethereum.chainId for production.');
+        return DEFAULT_DEV_CHAIN_ID;
+    })();
+    return {
+        kind: 'embedded',
+        chainType: ChainTypeEnum.EVM,
+        isConnected(state) {
+            return hasEmbeddedEthereum(state);
+        },
+        getChainId() {
+            return effectiveChainId;
+        },
+        getAddress(state) {
+            if (state.activeEmbeddedAddress)
+                return state.activeEmbeddedAddress;
+            return firstEmbeddedAddress(state.embeddedAccounts, ChainTypeEnum.EVM);
+        },
+        getConnectRoutes() {
+            return ['embedded'];
+        },
+        getConnectors() {
+            return [];
+        },
+        async initProvider(openfort, config, chainIdOverride) {
+            var _a, _b;
+            const ethereum = config === null || config === void 0 ? void 0 : config.ethereum;
+            const chainId = (_a = chainIdOverride !== null && chainIdOverride !== void 0 ? chainIdOverride : ethereum === null || ethereum === void 0 ? void 0 : ethereum.chainId) !== null && _a !== void 0 ? _a : DEFAULT_DEV_CHAIN_ID;
+            const rpcUrls = (_b = ethereum === null || ethereum === void 0 ? void 0 : ethereum.rpcUrls) !== null && _b !== void 0 ? _b : {};
+            const feeSponsorshipObj = resolveEthereumFeeSponsorship(config, chainId);
+            const provider = await openfort.embeddedWallet.getEthereumProvider({
+                ...feeSponsorshipObj,
+                chains: rpcUrls,
+            });
+            // Tell the provider which chain is active (EIP-1193). Without this, the provider
+            // stays on its initial chain (e.g. 80002) while fee sponsorship resolution is per-chain.
+            // 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 !== 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 openfort.auth.logout();
+        },
+    };
+}
+
+export { createEthereumEmbeddedStrategy };
+//# sourceMappingURL=EthereumEmbeddedStrategy.js.map

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

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

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

@@ -0,0 +1,9 @@
+import type { OpenfortWalletConfig } from '../../components/Openfort/types';
+import type { ConnectionStrategy } from '../ConnectionStrategy';
+/**
+ * Creates the Solana embedded strategy. Returns null if walletConfig.solana is not set.
+ *
+ * @param walletConfig - Wallet config with solana config
+ * @returns ConnectionStrategy or null
+ */
+export declare function createSolanaEmbeddedStrategy(walletConfig: OpenfortWalletConfig | undefined): ConnectionStrategy | null;

package/build/core/strategies/SolanaEmbeddedStrategy.js

@@ -0,0 +1,53 @@
+import { ChainTypeEnum, EmbeddedState } from '@openfort/openfort-js';
+import { firstEmbeddedAddress } from '../strategyUtils.js';
+
+function hasEmbeddedSolana(state) {
+    var _a, _b;
+    if (!state.user || !state.activeEmbeddedAddress || state.embeddedState !== EmbeddedState.READY)
+        return false;
+    return ((_b = (_a = state.embeddedAccounts) === null || _a === void 0 ? void 0 : _a.some((a) => a.chainType === ChainTypeEnum.SVM && a.address === state.activeEmbeddedAddress)) !== null && _b !== void 0 ? _b : false);
+}
+/**
+ * Creates the Solana embedded strategy. Returns null if walletConfig.solana is not set.
+ *
+ * @param walletConfig - Wallet config with solana config
+ * @returns ConnectionStrategy or null
+ */
+function createSolanaEmbeddedStrategy(walletConfig) {
+    if (!(walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana))
+        return null;
+    return {
+        kind: 'embedded',
+        chainType: ChainTypeEnum.SVM,
+        isConnected(state) {
+            return hasEmbeddedSolana(state);
+        },
+        getChainId() {
+            return undefined;
+        },
+        getAddress(state) {
+            var _a;
+            if (state.activeEmbeddedAddress) {
+                const svm = (_a = state.embeddedAccounts) === null || _a === void 0 ? void 0 : _a.find((a) => a.chainType === ChainTypeEnum.SVM && a.address === state.activeEmbeddedAddress);
+                if (svm)
+                    return svm.address;
+            }
+            return firstEmbeddedAddress(state.embeddedAccounts, ChainTypeEnum.SVM);
+        },
+        getConnectRoutes() {
+            return ['embedded'];
+        },
+        getConnectors() {
+            return [];
+        },
+        async initProvider() {
+            return;
+        },
+        async disconnect(openfort) {
+            await openfort.auth.logout();
+        },
+    };
+}
+
+export { createSolanaEmbeddedStrategy };
+//# sourceMappingURL=SolanaEmbeddedStrategy.js.map

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

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

package/build/core/strategyUtils.d.ts

@@ -0,0 +1,6 @@
+import type { ChainTypeEnum, EmbeddedAccount } from '@openfort/openfort-js';
+import type { OpenfortWalletConfig } from '../components/Openfort/types';
+export declare function firstEmbeddedAddress(accounts: EmbeddedAccount[] | undefined, chainType: ChainTypeEnum): string | undefined;
+export declare function resolveEthereumFeeSponsorship(config: OpenfortWalletConfig | undefined, chainId: number): {
+    policy: string;
+} | undefined;

package/build/core/strategyUtils.js

@@ -0,0 +1,31 @@
+import { RecoveryMethod } from '@openfort/openfort-js';
+
+function firstEmbeddedAddress(accounts, chainType) {
+    if (!(accounts === null || accounts === void 0 ? void 0 : accounts.length))
+        return undefined;
+    const forChain = accounts.filter((a) => a.chainType === chainType);
+    if (!forChain.length)
+        return undefined;
+    const automatic = forChain.find((a) => a.recoveryMethod === RecoveryMethod.AUTOMATIC);
+    if (automatic)
+        return automatic.address;
+    const passkey = forChain.find((a) => a.recoveryMethod === RecoveryMethod.PASSKEY);
+    if (passkey)
+        return passkey.address;
+    return forChain[0].address;
+}
+function resolveEthereumFeeSponsorship(config, chainId) {
+    var _a;
+    const feeSponsorship = (_a = config === null || config === void 0 ? void 0 : config.ethereum) === null || _a === void 0 ? void 0 : _a.ethereumFeeSponsorshipId;
+    if (!feeSponsorship)
+        return undefined;
+    if (typeof feeSponsorship === 'string')
+        return { policy: feeSponsorship };
+    if (typeof feeSponsorship === 'object' && chainId in feeSponsorship) {
+        return { policy: feeSponsorship[chainId] };
+    }
+    return undefined;
+}
+
+export { firstEmbeddedAddress, resolveEthereumFeeSponsorship };
+//# sourceMappingURL=strategyUtils.js.map

package/build/core/strategyUtils.js.map

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

package/build/ethereum/OpenfortEthereumBridgeContext.d.ts

@@ -0,0 +1,87 @@
+interface OpenfortEthereumBridgeChain {
+    id: number;
+    name?: string;
+}
+export interface OpenfortEthereumBridgeConnector {
+    id: string;
+    name: string;
+    icon?: string;
+    type?: string;
+    /** Optional; provided by wagmi connectors. Used when deciding QR vs injector flow. */
+    getProvider?: () => Promise<unknown>;
+}
+export interface OpenfortEthereumBridgeAccount {
+    address: `0x${string}` | undefined;
+    chain?: OpenfortEthereumBridgeChain;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isReconnecting: boolean;
+    connector?: OpenfortEthereumBridgeConnector;
+    ensName?: string;
+    ensAvatar?: string;
+}
+interface OpenfortEthereumBridgeStorage {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => void;
+}
+export interface OpenfortEthereumBridgeConfig {
+    chains: {
+        id: number;
+    }[];
+    getClient: (opts: {
+        chainId: number;
+    }) => {
+        transport: {
+            url: string;
+        };
+    };
+    storage?: OpenfortEthereumBridgeStorage;
+}
+export interface OpenfortEthereumBridgeSwitchChain {
+    chains: OpenfortEthereumBridgeChain[];
+    switchChain: ((params: {
+        chainId: number;
+    }) => void) | undefined;
+    switchChainAsync?: (params: {
+        chainId: number;
+    }) => Promise<unknown>;
+    isPending: boolean;
+    error: Error | null;
+}
+export interface OpenfortEthereumBridgeValue {
+    account: OpenfortEthereumBridgeAccount;
+    chainId: number;
+    config: OpenfortEthereumBridgeConfig;
+    disconnect: () => Promise<void>;
+    connect: (params: {
+        connector: OpenfortEthereumBridgeConnector;
+    }) => void;
+    connectAsync?: (params: {
+        connector: OpenfortEthereumBridgeConnector;
+    }) => Promise<unknown>;
+    reset: () => void;
+    connectors: OpenfortEthereumBridgeConnector[];
+    switchChain: OpenfortEthereumBridgeSwitchChain;
+    getEnsAddress?: (name: string) => Promise<`0x${string}` | undefined>;
+    getEnsName?: (params: {
+        address: `0x${string}`;
+    }) => Promise<string | undefined>;
+    getEnsAvatar?: (name: string) => Promise<string | undefined>;
+    getConnectorAccounts?: (connector: OpenfortEthereumBridgeConnector) => Promise<`0x${string}`[]>;
+    signMessage?: (params: {
+        message: string;
+    }) => Promise<`0x${string}`>;
+    getWalletClient?: () => Promise<import('viem').WalletClient | undefined>;
+}
+/**
+ * Context for the wagmi bridge. Provides account, chain, connectors, and switchChain.
+ * When using OpenfortProvider with wagmi, this is populated by OpenfortWagmiBridge.
+ */
+export declare const OpenfortEthereumBridgeContext: import("react").Context<OpenfortEthereumBridgeValue | null>;
+/**
+ * Returns the wagmi bridge value when using OpenfortProvider with wagmi. Null when EVM-only.
+ *
+ * @returns Bridge value with account, chainId, connectors, switchChain, etc. or null
+ */
+export declare function useEthereumBridge(): OpenfortEthereumBridgeValue | null;
+export {};

package/build/ethereum/OpenfortEthereumBridgeContext.js

@@ -0,0 +1,18 @@
+import { createContext, useContext } from 'react';
+
+/**
+ * Context for the wagmi bridge. Provides account, chain, connectors, and switchChain.
+ * When using OpenfortProvider with wagmi, this is populated by OpenfortWagmiBridge.
+ */
+const OpenfortEthereumBridgeContext = createContext(null);
+/**
+ * Returns the wagmi bridge value when using OpenfortProvider with wagmi. Null when EVM-only.
+ *
+ * @returns Bridge value with account, chainId, connectors, switchChain, etc. or null
+ */
+function useEthereumBridge() {
+    return useContext(OpenfortEthereumBridgeContext);
+}
+
+export { OpenfortEthereumBridgeContext, useEthereumBridge };
+//# sourceMappingURL=OpenfortEthereumBridgeContext.js.map

package/build/ethereum/OpenfortEthereumBridgeContext.js.map

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

package/build/ethereum/hooks/getEmbeddedWalletClient.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared logic for creating viem wallet client from embedded Ethereum provider.
+ * Used by useGrantPermissions and useRevokePermissions.
+ */
+import type { Chain } from 'viem';
+import { createWalletClient } from 'viem';
+import type { OpenfortEmbeddedEthereumWalletProvider } from '../types';
+/**
+ * Create viem wallet client from embedded provider.
+ * When extendErc7715 is true, returns client with grantPermissions etc.
+ */
+export declare function getEmbeddedWalletClient(provider: OpenfortEmbeddedEthereumWalletProvider, chain: Chain, options?: {
+    extendErc7715?: boolean;
+}): Promise<ReturnType<ReturnType<typeof createWalletClient>['extend']> | ReturnType<typeof createWalletClient>>;

package/build/ethereum/hooks/getEmbeddedWalletClient.js

@@ -0,0 +1,24 @@
+import { custom, createWalletClient } from 'viem';
+import { erc7715Actions } from 'viem/experimental';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+
+/**
+ * Shared logic for creating viem wallet client from embedded Ethereum provider.
+ * Used by useGrantPermissions and useRevokePermissions.
+ */
+/**
+ * Create viem wallet client from embedded provider.
+ * When extendErc7715 is true, returns client with grantPermissions etc.
+ */
+async function getEmbeddedWalletClient(provider, chain, options) {
+    const accounts = (await provider.request({ method: 'eth_accounts' }));
+    if (!(accounts === null || accounts === void 0 ? void 0 : accounts.length))
+        throw new OpenfortError('No accounts available', OpenfortReactErrorType.WALLET_ERROR);
+    const account = accounts[0];
+    const transport = custom(provider);
+    const baseClient = createWalletClient({ account, chain, transport });
+    return (options === null || options === void 0 ? void 0 : options.extendErc7715) ? baseClient.extend(erc7715Actions()) : baseClient;
+}
+
+export { getEmbeddedWalletClient };
+//# sourceMappingURL=getEmbeddedWalletClient.js.map

package/build/ethereum/hooks/getEmbeddedWalletClient.js.map

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

package/build/ethereum/hooks/useEthereumEmbeddedWallet.d.ts

@@ -0,0 +1,17 @@
+import type { EthereumWalletState, UseEmbeddedEthereumWalletOptions } from '../types';
+/**
+ * Returns state for EVM embedded wallets: create, recover, list, active wallet, and provider.
+ * Use for creating accounts, recovering existing ones, and signing transactions.
+ *
+ * @param options - Optional chainId override for multi-chain
+ * @returns State with status, wallets, activeWallet, create, recover, setActive, provider
+ *
+ * @example
+ * ```tsx
+ * const evm = useEthereumEmbeddedWallet()
+ * if (evm.status === 'connected') {
+ *   const sig = await evm.provider?.request({ method: 'personal_sign', params: [hash, address] })
+ * }
+ * ```
+ */
+export declare function useEthereumEmbeddedWallet(options?: UseEmbeddedEthereumWalletOptions): EthereumWalletState;