@openfort/react 1.0.14 → 1.0.16

package/build/core/ConnectionStrategy.d.ts

@@ -25,11 +25,7 @@ export interface ConnectionStrategy {
     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.
-     * @param activeEmbeddedAddress - Active embedded account address. When undefined, EVM strategies skip
-     *   `wallet_switchEthereumChain` to avoid sending `account: null` to /v2/accounts/switch-chain (422).
-     */
-    initProvider(openfort: Openfort, walletConfig: OpenfortWalletConfig, chainId?: number, activeEmbeddedAddress?: string): Promise<void>;
+    /** @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/strategies/EthereumBridgeStrategy.js

@@ -32,7 +32,7 @@ function createEthereumBridgeStrategy(bridge, connectors) {
         getConnectors() {
             return connectors;
         },
-        async initProvider(openfort, walletConfig, chainIdOverride, activeEmbeddedAddress) {
+        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) => {
@@ -53,21 +53,23 @@ function createEthereumBridgeStrategy(bridge, connectors) {
                 },
             });
             // 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.
-            // Skip if no active embedded account: openfort-js sends `account: null` to
-            // /v2/accounts/switch-chain → 422. eth_accounts isn't a reliable proxy here —
-            // it returns the signer address even when the active account isn't set yet.
-            if (chainId != null && chainId !== lastInitChainId && activeEmbeddedAddress) {
-                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);
-                }
+            // Real iframe-state check: throws when Account.fromStorage is empty (signer not yet
+            // configured by configure/create/recover). Avoids spurious /v2/accounts/switch-chain
+            // calls (422 with account=null) and redundant calls when already on target chain.
+            if (chainId == null || chainId === lastInitChainId)
+                return;
+            const wallet = await openfort.embeddedWallet.get().catch(() => null);
+            if (!(wallet === null || wallet === void 0 ? void 0 : wallet.address) || wallet.chainId === chainId)
+                return;
+            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) {

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

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

package/build/core/strategies/EthereumEmbeddedStrategy.js

@@ -44,7 +44,7 @@ function createEthereumEmbeddedStrategy(walletConfig) {
         getConnectors() {
             return [];
         },
-        async initProvider(openfort, config, chainIdOverride, activeEmbeddedAddress) {
+        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;
@@ -56,21 +56,23 @@ function createEthereumEmbeddedStrategy(walletConfig) {
             });
             // 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.
-            // Skip if no active embedded account: openfort-js sends `account: null` to
-            // /v2/accounts/switch-chain → 422. eth_accounts isn't a reliable proxy here —
-            // it returns the signer address even when the active account isn't set yet.
-            if (chainId !== lastInitChainId && activeEmbeddedAddress) {
-                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);
-                }
+            // Real iframe-state check: throws when Account.fromStorage is empty (signer not yet
+            // configured by configure/create/recover). Avoids spurious /v2/accounts/switch-chain
+            // calls (422 with account=null) and redundant calls when already on target chain.
+            if (chainId === lastInitChainId)
+                return;
+            const wallet = await openfort.embeddedWallet.get().catch(() => null);
+            if (!(wallet === null || wallet === void 0 ? void 0 : wallet.address) || wallet.chainId === chainId)
+                return;
+            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) {

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

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

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/openfort/CoreOpenfortProvider.js

@@ -245,24 +245,13 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
         }
         // Skip if we already initialized with the same parameters
         const feeSponsorshipPolicy = evmChainId != null ? (_a = resolveEthereumFeeSponsorship(walletConfig, evmChainId)) === null || _a === void 0 ? void 0 : _a.policy : undefined;
-        // Track whether we had an active embedded address at init time. When it transitions
-        // from absent → present, we re-init so wallet_switchEthereumChain can finally fire
-        // (openfort-js needs the active account set, otherwise it sends `account: null` → 422).
-        const hasActiveEmbeddedAddress = !!storeActiveEmbeddedAddress;
-        const initKey = {
-            kind: strategy.kind,
-            chainType: strategy.chainType,
-            evmChainId,
-            feeSponsorshipPolicy,
-            hasActiveEmbeddedAddress,
-        };
+        const initKey = { kind: strategy.kind, chainType: strategy.chainType, evmChainId, feeSponsorshipPolicy };
         const prev = lastInitRef.current;
         if (prev &&
             prev.kind === initKey.kind &&
             prev.chainType === initKey.chainType &&
             prev.evmChainId === initKey.evmChainId &&
-            prev.feeSponsorshipPolicy === initKey.feeSponsorshipPolicy &&
-            prev.hasActiveEmbeddedAddress === initKey.hasActiveEmbeddedAddress) {
+            prev.feeSponsorshipPolicy === initKey.feeSponsorshipPolicy) {
             return;
         }
         // Prevent concurrent initProvider calls
@@ -272,7 +261,7 @@ const CoreOpenfortProvider = ({ children, onConnect, onDisconnect, openfortConfi
         initInProgressRef.current = true;
         let cancelled = false;
         strategy
-            .initProvider(openfort, walletConfig, evmChainId, storeActiveEmbeddedAddress !== null && storeActiveEmbeddedAddress !== void 0 ? storeActiveEmbeddedAddress : undefined)
+            .initProvider(openfort, walletConfig, evmChainId)
             .then(() => {
             if (cancelled)
                 return;

package/build/openfort/CoreOpenfortProvider.js.map

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

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.14";
+export declare const OPENFORT_VERSION = "1.0.16";

package/build/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -65,7 +65,7 @@
     "react"
   ],
   "dependencies": {
-    "@openfort/openfort-js": "^1.2.1",
+    "@openfort/openfort-js": "1.3.4",
     "buffer": "^6.0.3",
     "detect-browser": "^5.3.0",
     "fast-password-entropy": "^1.1.1",