@openfort/react 1.0.15 → 1.1.0

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js

@@ -179,6 +179,70 @@ function useEthereumEmbeddedWallet(options) {
         updateEmbeddedAccounts,
         setActiveEmbeddedAddress,
     ]);
+    const importWallet = useCallback(async (importOptions) => {
+        var _a, _b, _c, _d, _e, _f;
+        setState((s) => ({ ...s, status: 'creating', error: null }));
+        try {
+            if (!walletConfig) {
+                throw new OpenfortError('Wallet config not found', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            const recoveryParams = await buildRecoveryParams({
+                recoveryMethod: importOptions.recoveryMethod,
+                passkeyId: importOptions.passkeyId,
+                password: importOptions.password,
+                otpCode: importOptions.otpCode,
+            }, {
+                walletConfig,
+                getAccessToken: () => client.getAccessToken(),
+                getUserId: async () => {
+                    const user = await client.user.get();
+                    return user === null || user === void 0 ? void 0 : user.id;
+                },
+            });
+            const accountType = (_c = (_a = importOptions.accountType) !== null && _a !== void 0 ? _a : (_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _b === void 0 ? void 0 : _b.accountType) !== null && _c !== void 0 ? _c : DEFAULT_ACCOUNT_TYPE;
+            const account = await client.embeddedWallet.import({
+                privateKey: importOptions.privateKey,
+                chainType: ChainTypeEnum.EVM,
+                accountType,
+                ...(accountType !== DEFAULT_ACCOUNT_TYPE && { chainId: (_d = importOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
+                recoveryParams,
+            });
+            setActiveEmbeddedAddress(account.address);
+            await updateEmbeddedAccounts({ silent: true });
+            const provider = await getEmbeddedEthereumProvider();
+            const connectedWallet = buildConnectedWallet(account, 0, async () => provider, {
+                isActive: true,
+                isConnecting: false,
+            });
+            setState({
+                status: 'connected',
+                activeWallet: connectedWallet,
+                provider,
+                error: null,
+            });
+            (_e = importOptions.onSuccess) === null || _e === void 0 ? void 0 : _e.call(importOptions, { account });
+            return account;
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to import Ethereum wallet', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            setState((s) => ({
+                ...s,
+                status: 'error',
+                error: error.message,
+            }));
+            (_f = importOptions.onError) === null || _f === void 0 ? void 0 : _f.call(importOptions, error);
+            throw error;
+        }
+    }, [
+        client,
+        walletConfig,
+        creationChainId,
+        getEmbeddedEthereumProvider,
+        updateEmbeddedAccounts,
+        setActiveEmbeddedAddress,
+    ]);
     const setActive = useCallback(async (activeOptions) => {
         const run = async () => {
             var _a, _b, _c, _d, _e;
@@ -302,11 +366,12 @@ function useEthereumEmbeddedWallet(options) {
     }, [client]);
     const actions = useMemo(() => ({
         create,
+        import: importWallet,
         wallets,
         setActive,
         setRecovery,
         exportPrivateKey,
-    }), [create, wallets, setActive, setRecovery, exportPrivateKey]);
+    }), [create, importWallet, wallets, setActive, setRecovery, exportPrivateKey]);
     // Use refs for values that should NOT re-trigger the sync effect.
     const stateRef = useRef(state);
     stateRef.current = state;

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

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

package/build/ethereum/types.d.ts

@@ -5,7 +5,7 @@
  */
 import type { AccountTypeEnum, ChainTypeEnum, EmbeddedAccount, RecoveryMethod, RecoveryParams } from '@openfort/openfort-js';
 import type { Hex } from 'viem';
-import type { ConnectedWalletState, CreateEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SharedSetRecoveryOptions, WalletDerived } from '../shared/types';
+import type { ConnectedWalletState, CreateEmbeddedWalletOptions, ImportEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SharedSetRecoveryOptions, WalletDerived } from '../shared/types';
 export type FeeSponsorshipConfig = string | Record<number, string>;
 export type EthereumConfig = {
     /** Initial chain ID for the embedded wallet provider.
@@ -70,6 +70,8 @@ export type SetActiveEthereumWalletOptions = SetActiveEmbeddedWalletOptionsBase
 export interface EthereumWalletActions {
     /** Create a new Ethereum embedded wallet */
     create(options?: CreateEmbeddedWalletOptions): Promise<EmbeddedAccount>;
+    /** Import an Ethereum embedded wallet from a hex-encoded private key */
+    import(options: ImportEmbeddedWalletOptions): Promise<EmbeddedAccount>;
     /** List of available Ethereum wallets */
     wallets: ConnectedEmbeddedEthereumWallet[];
     /** Set the active wallet */

package/build/shared/types.d.ts

@@ -63,3 +63,11 @@ export type CreateEmbeddedWalletOptions = {
     /** Fee sponsorship ID for gas sponsorship */
     feeSponsorshipId?: string;
 } & OpenfortHookOptions<CreateEmbeddedWalletResult>;
+/**
+ * Options for importing an embedded wallet from a raw private key.
+ * EVM expects a hex-encoded private key; Solana expects a base58-encoded secret key.
+ */
+export type ImportEmbeddedWalletOptions = CreateEmbeddedWalletOptions & {
+    /** Raw private key (hex for EVM, base58 for Solana). */
+    privateKey: string;
+};

package/build/solana/hooks/useSolanaEmbeddedWallet.js

@@ -156,6 +156,62 @@ function useSolanaEmbeddedWallet(options) {
             throw error;
         }
     }, [client, walletConfig, createProviderForAccount, updateEmbeddedAccounts, setActiveEmbeddedAddress]);
+    const importWallet = useCallback(async (importOptions) => {
+        var _a, _b;
+        setState((s) => ({ ...s, status: 'creating', error: null }));
+        try {
+            if (!walletConfig) {
+                throw new OpenfortError('Wallet config not found', OpenfortReactErrorType.CONFIGURATION_ERROR);
+            }
+            const recoveryParams = await buildRecoveryParams({
+                recoveryMethod: importOptions.recoveryMethod,
+                passkeyId: importOptions.passkeyId,
+                password: importOptions.password,
+                otpCode: importOptions.otpCode,
+            }, {
+                walletConfig,
+                getAccessToken: () => client.getAccessToken(),
+                getUserId: () => client.user.get().then((u) => u === null || u === void 0 ? void 0 : u.id),
+            });
+            const account = await client.embeddedWallet.import({
+                privateKey: importOptions.privateKey,
+                chainType: ChainTypeEnum.SVM,
+                accountType: AccountTypeEnum.EOA,
+                recoveryParams,
+            });
+            setActiveEmbeddedAddress(account.address);
+            await updateEmbeddedAccounts({ silent: true });
+            const provider = createProviderForAccount(account);
+            const connectedWallet = {
+                id: account.id,
+                address: account.address,
+                chainType: ChainTypeEnum.SVM,
+                walletIndex: 0,
+                recoveryMethod: account.recoveryMethod,
+                getProvider: async () => provider,
+            };
+            setState({
+                status: 'connected',
+                activeWallet: connectedWallet,
+                provider,
+                error: null,
+            });
+            (_a = importOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(importOptions, { account });
+            return account;
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to import Solana wallet', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            setState((s) => ({
+                ...s,
+                status: 'error',
+                error: error.message,
+            }));
+            (_b = importOptions.onError) === null || _b === void 0 ? void 0 : _b.call(importOptions, error);
+            throw error;
+        }
+    }, [client, walletConfig, createProviderForAccount, updateEmbeddedAccounts, setActiveEmbeddedAddress]);
     const setActive = useCallback(async (activeOptions) => {
         const run = async () => {
             const accounts = solanaAccountsRef.current;
@@ -261,11 +317,12 @@ function useSolanaEmbeddedWallet(options) {
     }, [client]);
     const actions = useMemo(() => ({
         create,
+        import: importWallet,
         wallets,
         setActive,
         setRecovery,
         exportPrivateKey,
-    }), [create, wallets, setActive, setRecovery, exportPrivateKey]);
+    }), [create, importWallet, wallets, setActive, setRecovery, exportPrivateKey]);
     // Clear local state when core clears activeEmbeddedAddress (e.g. logout).
     useEffect(() => {
         if (!activeEmbeddedAddress && (state.status === 'connected' || state.status === 'needs-recovery')) {

package/build/solana/hooks/useSolanaEmbeddedWallet.js.map

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

package/build/solana/types.d.ts

@@ -5,7 +5,7 @@
  */
 import type { ChainTypeEnum, EmbeddedAccount, RecoveryMethod, RecoveryParams } from '@openfort/openfort-js';
 import type React from 'react';
-import type { ConnectedWalletState, CreateEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SetRecoveryOptionsBase, WalletDerived } from '../shared/types';
+import type { ConnectedWalletState, CreateEmbeddedWalletOptions, ImportEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SetRecoveryOptionsBase, WalletDerived } from '../shared/types';
 /**
  * Solana cluster identifier
  */
@@ -177,6 +177,8 @@ export type SetActiveSolanaWalletOptions = SetActiveEmbeddedWalletOptionsBase &
 export interface SolanaWalletActions {
     /** Create a new Solana embedded wallet */
     create(options?: CreateEmbeddedWalletOptions): Promise<EmbeddedAccount>;
+    /** Import a Solana embedded wallet from a base58-encoded secret key */
+    import(options: ImportEmbeddedWalletOptions): Promise<EmbeddedAccount>;
     /** List of available Solana wallets */
     wallets: ConnectedEmbeddedSolanaWallet[];
     /** Set the active wallet */

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.0.15";
+export declare const OPENFORT_VERSION = "1.1.0";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.0.15';
+const OPENFORT_VERSION = '1.1.0';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

package/build/wagmi/defaultConnectors.js

@@ -13,7 +13,6 @@ const defaultConnectors = ({ app, walletConnectProjectId, coinbaseWalletPreferen
     connectors.push(coinbaseWallet({
         appName: app.name,
         appLogoUrl: app.icon,
-        overrideIsMetaMask: false,
         preference: coinbaseWalletPreference,
     }));
     if (walletConnectProjectId) {

package/build/wagmi/defaultConnectors.js.map

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

package/build/wagmi/embeddedConnector.js

@@ -62,6 +62,20 @@ function embeddedWalletConnector() {
             async getProvider() {
                 return _provider !== null && _provider !== void 0 ? _provider : undefined;
             },
+            async switchChain({ chainId }) {
+                const provider = _provider;
+                if (!provider)
+                    throw new Error('Embedded wallet provider not ready');
+                const chain = config.chains.find((c) => c.id === chainId);
+                if (!chain)
+                    throw new Error(`Chain ${chainId} is not configured`);
+                await provider.request({
+                    method: 'wallet_switchEthereumChain',
+                    params: [{ chainId: `0x${chainId.toString(16)}` }],
+                });
+                config.emitter.emit('change', { chainId });
+                return chain;
+            },
             async isAuthorized() {
                 if (!_provider)
                     return false;

package/build/wagmi/embeddedConnector.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.0.15",
+  "version": "1.1.0",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -65,47 +65,55 @@
     "react"
   ],
   "dependencies": {
-    "@openfort/openfort-js": "1.3.3",
+    "@openfort/openfort-js": "^1.3.5",
     "buffer": "^6.0.3",
     "detect-browser": "^5.3.0",
     "fast-password-entropy": "^1.1.1",
     "framer-motion": "^6.3.11",
     "qrcode": "^1.5.0",
     "react-international-phone": "^4.6.0",
-    "react-is": "^19.1.0",
+    "react-is": "^19.2.7",
     "react-transition-state": "^1.1.4",
     "react-use-measure": "^2.1.1",
     "resize-observer-polyfill": "^1.5.1",
     "styled-components": "^5.3.5",
-    "zustand": "^5.0.11"
+    "zustand": "^5.0.14"
   },
   "peerDependencies": {
+    "@coinbase/wallet-sdk": "^4.3.6",
+    "@safe-global/safe-apps-provider": "~0.18.6",
+    "@safe-global/safe-apps-sdk": "^9.1.0",
     "@solana/kit": "^2.0.0 || ^5.0.0",
+    "@walletconnect/ethereum-provider": "^2.21.1",
     "react": "17.x || 18.x || 19.x",
     "react-dom": "17.x || 18.x || 19.x",
     "viem": "2.x",
-    "wagmi": "2.x"
+    "wagmi": "3.x"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.8",
-    "@tanstack/react-query": "^5.90.21",
+    "@biomejs/biome": "^2.4.16",
+    "@coinbase/wallet-sdk": "^4.3.7",
+    "@safe-global/safe-apps-provider": "~0.18.6",
+    "@safe-global/safe-apps-sdk": "^9.1.0",
+    "@tanstack/react-query": "^5.101.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/react-hooks": "^8.0.1",
-    "@types/node": "18.7.18",
+    "@types/node": "^25.9.2",
     "@types/qrcode": "^1.4.2",
     "@types/react": "^18.0.6",
     "@types/react-dom": "^18.0.2",
     "@types/styled-components": "^5.1.25",
-    "@wagmi/connectors": "^6.2.0",
-    "@wagmi/core": "^2.22.1",
-    "happy-dom": "^20.8.9",
-    "jsdom": "^28.1.0",
+    "@wagmi/connectors": "^8.0.15",
+    "@wagmi/core": "^3.5.0",
+    "@walletconnect/ethereum-provider": "^2.23.9",
+    "happy-dom": "^20.10.2",
+    "jsdom": "^29.1.1",
     "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "typescript": "^5.0.4",
+    "rollup-plugin-typescript2": "^0.37.0",
+    "typescript": "^5.9.3",
     "typescript-plugin-styled-components": "^2.0.0",
-    "vitest": "^2.0.0",
-    "wagmi": "^2.18.2"
+    "vitest": "^4.1.0",
+    "wagmi": "^3.6.16"
   },
   "peerDependenciesMeta": {
     "@solana/kit": {
@@ -114,6 +122,18 @@
     "wagmi": {
       "optional": true
     },
+    "@coinbase/wallet-sdk": {
+      "optional": true
+    },
+    "@walletconnect/ethereum-provider": {
+      "optional": true
+    },
+    "@safe-global/safe-apps-provider": {
+      "optional": true
+    },
+    "@safe-global/safe-apps-sdk": {
+      "optional": true
+    },
     "@tanstack/react-query": {
       "optional": true
     }