@abstraxn/signer-react 3.1.3 → 3.2.0

package/dist/src/hooks.js

@@ -4,7 +4,8 @@
 import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useAbstraxnWallet } from './AbstraxnProvider';
 import { InvalidDeviceIdError, SignMfaRequiredError } from '@abstraxn/signer-core';
-import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, encodeFunctionData, hashTypedData } from 'viem';
+import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, encodeFunctionData, hashTypedData, hashMessage, parseSignature } from 'viem';
+import { toAccount } from 'viem/accounts';
 import { Connection as SolanaConnection, Transaction as SolanaTransaction, SystemProgram, PublicKey, LAMPORTS_PER_SOL, TransactionInstruction, } from '@solana/web3.js';
 import { useWalletClient as useWagmiWalletClient, useAccount, useConfig, useChainId as useWagmiChainId, useSwitchChain as useWagmiSwitchChain, useSignMessage as useWagmiSignMessage, useReconnect as useWagmiReconnect } from 'wagmi';
 import { getWalletClient, switchChain } from '@wagmi/core';
@@ -72,6 +73,67 @@ export function useWallet() {
     const { wallet } = useAbstraxnWallet();
     return wallet;
 }
+/**
+ * Hook to get an AA-compatible owner account for permissionless-compatible SDKs.
+ * This does not include bundler/paymaster integration; apps can plug in any provider.
+ */
+export function useSmartAccountOwner(options = {}) {
+    const { isConnected, address: connectedAddress, signTransactionViaAPI, signTypedTxViaAPI, verifySignMfa, } = useAbstraxnWallet();
+    const ownerAddress = (options.address ?? connectedAddress ?? null);
+    const smartAccountOwner = useMemo(() => {
+        if (!isConnected || !ownerAddress)
+            return null;
+        return toAccount({
+            address: ownerAddress,
+            /**
+             * ERC-4337 SimpleAccount (permissionless) signs UserOperations via viem `signMessage` with
+             * `message: { raw: userOpHash }`. That requires the same digest as viem local accounts:
+             * EIP-191 `hashMessage(message)`, then ECDSA sign that 32-byte digest — not UTF-8 text hashing.
+             */
+            async signMessage({ message }) {
+                const digest = hashMessage(message);
+                const signature = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, digest, 'PAYLOAD_ENCODING_HEXADECIMAL', 'HASH_FUNCTION_NO_OP').then((res) => res.signature), verifySignMfa);
+                return (signature.startsWith('0x') ? signature : `0x${signature}`);
+            },
+            async signTransaction(transaction) {
+                const unsignedTransaction = serializeTransaction(transaction);
+                const result = await runWithSignStepUpRetry(() => signTransactionViaAPI(unsignedTransaction, ownerAddress), verifySignMfa);
+                return result.signedTransaction;
+            },
+            async signTypedData(typedData) {
+                const digest = hashTypedData(typedData);
+                const result = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, digest, 'PAYLOAD_ENCODING_EIP712', 'HASH_FUNCTION_NO_OP'), verifySignMfa);
+                const signature = result.signature;
+                return (signature.startsWith('0x') ? signature : `0x${signature}`);
+            },
+            /** EIP-7702: sign delegation authorization (`keccak256(0x05 || rlp(...))`) via backend, same as raw ECDSA over digest. */
+            async signAuthorization(parameters) {
+                const authorizationAddress = parameters.contractAddress ?? parameters.address;
+                const authorizationPayload = JSON.stringify({
+                    chainId: parameters.chainId,
+                    address: authorizationAddress,
+                    nonce: parameters.nonce,
+                });
+                const sig = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, authorizationPayload, 'PAYLOAD_ENCODING_EIP7702_AUTHORIZATION', 'HASH_FUNCTION_NOT_APPLICABLE').then((res) => res.signature), verifySignMfa);
+                const hex = (sig.startsWith('0x') ? sig : `0x${sig}`);
+                const { r, s, yParity } = parseSignature(hex);
+                return {
+                    address: authorizationAddress,
+                    chainId: parameters.chainId,
+                    nonce: parameters.nonce,
+                    r,
+                    s,
+                    yParity,
+                };
+            },
+        });
+    }, [isConnected, ownerAddress, signTransactionViaAPI, signTypedTxViaAPI, verifySignMfa]);
+    return {
+        smartAccountOwner,
+        isReady: !!smartAccountOwner,
+        address: ownerAddress,
+    };
+}
 /**
  * Hook to export wallet private key
  * Returns the export bundle containing the private key
@@ -414,6 +476,282 @@ export function useDisableMfa() {
         reset,
     };
 }
+const AUTH_METHOD_LINK_PROVIDER_ALLOWLIST = new Set([
+    'google',
+    'discord',
+    'x',
+    'passkey',
+]);
+const AUTH_METHOD_UNLINK_PROVIDER_ALLOWLIST = new Set([
+    'google',
+    'discord',
+    'x',
+    'email',
+    'passkey',
+]);
+function normalizeAuthMethodProviderForApi(provider) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === 'otp')
+        return 'email';
+    return normalized;
+}
+function normalizeAuthMethodProviderForMatch(provider) {
+    const normalized = normalizeAuthMethodProviderForApi(provider);
+    if (normalized === 'twitter' || normalized === 'x')
+        return 'x';
+    return normalized;
+}
+function normalizeAuthMethodErrorMessage(message) {
+    return message.replace(/^network error:\s*/i, '').trim();
+}
+function toAuthMethodError(error, fallbackMessage) {
+    if (error instanceof Error) {
+        return new Error(normalizeAuthMethodErrorMessage(error.message || fallbackMessage));
+    }
+    if (typeof error === 'string' && error.trim() !== '') {
+        return new Error(normalizeAuthMethodErrorMessage(error));
+    }
+    return new Error(fallbackMessage);
+}
+/**
+ * Hook for linking/unlinking auth methods without any UI concerns.
+ * It exposes state and actions only; consumers own rendering and messaging.
+ */
+export function useAuthMethodLinking() {
+    const { wallet, whoami, getSupportedAuthMethods, getLinkedAuthMethods, requestOtpForEmailLink, loginWithOTP, } = useAbstraxnWallet();
+    const [supportedMethods, setSupportedMethods] = useState([]);
+    const [linkedMethods, setLinkedMethods] = useState([]);
+    const [queryLoading, setQueryLoading] = useState(false);
+    const [actionProvider, setActionProvider] = useState(null);
+    const [error, setError] = useState(null);
+    const requireConnectedWallet = useCallback(() => {
+        if (!wallet?.isConnected) {
+            throw new Error('Wallet not connected');
+        }
+        return wallet;
+    }, [wallet]);
+    const refreshAuthMethods = useCallback(async (_options) => {
+        const activeWallet = requireConnectedWallet();
+        setQueryLoading(true);
+        setError(null);
+        try {
+            const supportedRequest = getSupportedAuthMethods != null
+                ? getSupportedAuthMethods()
+                : activeWallet.getSupportedAuthMethods();
+            const linkedRequest = getLinkedAuthMethods != null
+                ? getLinkedAuthMethods()
+                : activeWallet.getLinkedAuthMethods();
+            const [supportedResponse, linkedResponse] = await Promise.all([
+                supportedRequest,
+                linkedRequest,
+            ]);
+            const loginProvider = normalizeAuthMethodProviderForMatch(String(whoami?.loginProvider ?? ''));
+            const allSupportedMethods = supportedResponse.supportedMethods ?? [];
+            const filteredMethods = loginProvider !== ''
+                ? allSupportedMethods.filter((method) => normalizeAuthMethodProviderForMatch(method.provider) !== loginProvider)
+                : allSupportedMethods;
+            setSupportedMethods(filteredMethods);
+            setLinkedMethods(linkedResponse.linkedMethods ?? []);
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to load auth methods');
+            setSupportedMethods([]);
+            setLinkedMethods([]);
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setQueryLoading(false);
+        }
+    }, [getLinkedAuthMethods, getSupportedAuthMethods, requireConnectedWallet, whoami]);
+    const isLinked = useCallback((provider) => {
+        const normalizedProvider = normalizeAuthMethodProviderForMatch(provider);
+        return linkedMethods.some((method) => normalizeAuthMethodProviderForMatch(method.authProvider) === normalizedProvider);
+    }, [linkedMethods]);
+    const runOAuthPopupLink = useCallback(async (activeWallet, provider) => {
+        if (typeof window === 'undefined') {
+            throw new Error('OAuth linking requires a browser environment');
+        }
+        const { authUrl } = await activeWallet.initiateLinkAuth(provider);
+        const width = 500;
+        const height = 600;
+        const left = Math.round((window.screen.width - width) / 2);
+        const top = Math.round((window.screen.height - height) / 2);
+        const popup = window.open(authUrl, 'abstraxn-auth-link', `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`);
+        if (!popup) {
+            throw new Error('Popup blocked. Please allow popups for this site.');
+        }
+        const timeoutMs = 120000;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let closeCheckId = null;
+            let timeoutId = null;
+            const finalizeReject = (reason) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(new Error(reason));
+            };
+            const cleanup = () => {
+                window.removeEventListener('message', onMessage);
+                if (closeCheckId != null)
+                    clearInterval(closeCheckId);
+                if (timeoutId != null)
+                    clearTimeout(timeoutId);
+            };
+            const onMessage = (event) => {
+                if (event.origin !== window.location.origin)
+                    return;
+                if (event.source !== popup)
+                    return;
+                const data = event.data;
+                if (!data?.type)
+                    return;
+                const eventProvider = normalizeAuthMethodProviderForMatch(String(data.provider ?? ''));
+                const targetProvider = normalizeAuthMethodProviderForMatch(provider);
+                if (eventProvider !== targetProvider)
+                    return;
+                if (data.type === 'abstraxn-auth-link-error') {
+                    finalizeReject(normalizeAuthMethodErrorMessage(String(data.error ?? 'Failed to link auth method')));
+                    return;
+                }
+                if (data.type === 'abstraxn-auth-link-done') {
+                    if (!data.activityBody || data.activityBody.trim() === '') {
+                        finalizeReject('Invalid linking response');
+                        return;
+                    }
+                    settled = true;
+                    cleanup();
+                    activeWallet
+                        .submitLinkAuthStamped(provider, data.activityBody)
+                        .then(resolve)
+                        .catch((submitError) => {
+                        reject(toAuthMethodError(submitError, 'Failed to finalize auth method link'));
+                    });
+                }
+            };
+            window.addEventListener('message', onMessage);
+            closeCheckId = setInterval(() => {
+                if (popup.closed) {
+                    finalizeReject('Linking was cancelled');
+                }
+            }, 200);
+            timeoutId = setTimeout(() => {
+                finalizeReject('Linking timed out. Please try again.');
+            }, timeoutMs);
+        });
+    }, [wallet]);
+    const linkProvider = useCallback(async (provider) => {
+        const activeWallet = requireConnectedWallet();
+        const normalizedProvider = provider.toLowerCase();
+        if (!AUTH_METHOD_LINK_PROVIDER_ALLOWLIST.has(normalizedProvider)) {
+            throw new Error(`Unsupported provider for linking: ${provider}`);
+        }
+        setActionProvider(normalizedProvider);
+        setError(null);
+        try {
+            if (normalizedProvider === 'passkey') {
+                await activeWallet.linkPasskey();
+            }
+            else {
+                await runOAuthPopupLink(activeWallet, normalizedProvider);
+            }
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to link auth method');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet, runOAuthPopupLink]);
+    const requestEmailLinkOtp = useCallback(async (email) => {
+        const activeWallet = requireConnectedWallet();
+        const trimmedEmail = email.trim();
+        if (!trimmedEmail) {
+            throw new Error('Email is required');
+        }
+        setActionProvider('email');
+        setError(null);
+        try {
+            if (requestOtpForEmailLink) {
+                return await requestOtpForEmailLink(trimmedEmail);
+            }
+            if (loginWithOTP) {
+                return await loginWithOTP(trimmedEmail);
+            }
+            // Fallback to core method directly if context methods are unavailable.
+            return await activeWallet.requestOtpForEmailLink(trimmedEmail);
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to send email verification code');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [loginWithOTP, requestOtpForEmailLink, requireConnectedWallet]);
+    const confirmEmailLink = useCallback(async (otpId, otpCode) => {
+        const activeWallet = requireConnectedWallet();
+        const trimmedOtpId = otpId.trim();
+        const trimmedOtpCode = otpCode.trim();
+        if (!trimmedOtpId || !trimmedOtpCode) {
+            throw new Error('otpId and otpCode are required');
+        }
+        setActionProvider('email');
+        setError(null);
+        try {
+            await activeWallet.linkEmail(trimmedOtpId, trimmedOtpCode);
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to link email');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet]);
+    const unlinkProvider = useCallback(async (provider) => {
+        const activeWallet = requireConnectedWallet();
+        const normalizedProvider = normalizeAuthMethodProviderForApi(provider);
+        if (!AUTH_METHOD_UNLINK_PROVIDER_ALLOWLIST.has(normalizedProvider)) {
+            throw new Error(`Unsupported provider for unlinking: ${provider}`);
+        }
+        setActionProvider(normalizedProvider);
+        setError(null);
+        try {
+            await activeWallet.unlinkAuthMethod(normalizedProvider);
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to unlink auth method');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet]);
+    return {
+        supportedMethods,
+        linkedMethods,
+        loading: queryLoading || actionProvider !== null,
+        actionProvider,
+        error,
+        refreshAuthMethods,
+        isLinked,
+        linkProvider,
+        requestEmailLinkOtp,
+        confirmEmailLink,
+        unlinkProvider,
+    };
+}
 /**
  * Hook to access external wallet functionality
  * Returns external wallet connection state and methods
@@ -504,7 +842,7 @@ export function useExternalWalletChain() {
  * ```
  */
 export function useExternalWalletInfo() {
-    const { externalWalletChainId, externalWalletNetwork, isExternalWalletConnected, externalWalletAddress, externalWalletBalance, } = useExternalWallet();
+    const { externalWalletChainId, externalWalletNetwork, switchExternalWalletChain, isExternalWalletConnected, externalWalletAddress, externalWalletBalance, } = useExternalWallet();
     const { sendTransaction, signMessage, signTransaction, switchChain, } = useAbstraxnWallet();
     const [formattedBalance, setFormattedBalance] = useState('0');
     useEffect(() => {
@@ -571,8 +909,8 @@ export function useExternalWalletInfo() {
         // Balance information
         balance: externalWalletBalance, // BigInt in wei
         formattedBalance, // String formatted as ETH (e.g., "0.123456")
-        // Unified chain switch (embedded + external); not only switchExternalWalletChain.
-        switchChain,
+        // Chain switching
+        switchChain: switchExternalWalletChain,
         // Connection status
         isConnected: isExternalWalletConnected,
         address: externalWalletAddress,

package/dist/src/index.d.ts

@@ -4,14 +4,14 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useEmailForOtp, useWallet, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useWaitForSolanaConfirmation, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useWaitForSolanaConfirmation, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export type { ConnectButtonProps, ConnectButtonVariant, ConnectButtonSize } from './ConnectButton';
 export { WalletModal } from './WalletModal';
 export type { WalletModalProps } from './WalletModal';
 export { OnboardingUIComponent as OnboardingUI } from './OnboardingUI';
 export type { AbstraxnProviderConfig, AbstraxnUIConfig, AbstraxnContextValue, ChainConfig, } from './types';
-export type { PayloadEncoding, HashFunction, SignTypedTxParams, SolanaAccountMetaInput, SolanaInstructionDataInput, } from './hooks';
+export type { PayloadEncoding, HashFunction, SignTypedTxParams, SmartAccountOwnerOptions, SmartAccountOwnerResult, SolanaAccountMetaInput, SolanaInstructionDataInput, } from './hooks';
 export type { OnboardingUIComponentProps, OnboardingUIComponentRef } from './OnboardingUI';
 export { ALL_CHAINS, EVM_CHAINS, SOLANA_CHAINS, getChainById, getChainsByType, getDefaultChains, toCoreChain, type ChainData, } from './chains';
 export { CONNECTORS, getConnectorMeta, isOAuthConnector, isWalletConnector, isAuthConnector, type ConnectorType, type ConnectorMeta, } from './connectors';

package/dist/src/index.js

@@ -4,7 +4,7 @@
  * when used in a React project
  */
 export { AbstraxnProvider, useAbstraxnWallet } from './AbstraxnProvider';
-export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useEmailForOtp, useWallet, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useWaitForSolanaConfirmation, } from './hooks';
+export { useIsConnected, useAddress, useAuthContext, useChainId, useError, useEnableMfa, useDisableMfa, useAuthMethodLinking, useEmailForOtp, useWallet, useSmartAccountOwner, useExportWallet, useWhoami, useExternalWallet, useExternalWalletBalance, useExternalWalletChain, useExternalWalletInfo, usePublicClient, useWalletClient, useContract, usePrepareRawTxn, useSignTxn, useSignTypedTx, useSignAndSendTxn, useWaitForTxnReceipt, useReadContract, useExternalWalletClient, useWriteContract, useConnectionType, useSwitchChain, useSignMessage, useEstimateGas, useGetGasPrice, useSolanaConnection, useSolanaPublicKey, useSolanaBalance, usePrepareSolanaTxn, useSolanaExternalWallet, usePrepareSolanaProgramTxn, useSolanaProgramTransaction, useSignSolanaTxn, useSignAndSendSolanaTxn, useWaitForSolanaConfirmation, } from './hooks';
 export { ConnectButton } from './ConnectButton';
 export { WalletModal } from './WalletModal';
 export { OnboardingUIComponent as OnboardingUI } from './OnboardingUI';

package/dist/src/types.d.ts

@@ -273,7 +273,7 @@ export interface AbstraxnContextValue {
     availableChains?: import("./chains").ChainData[];
     walletBalance?: bigint | null;
     /** Refetch wallet balance from RPC (Abstraxn or external). Call when UI screen changes (e.g. back button, modal open/close). */
-    refetchBalance?: () => void;
+    refetchBalance?: () => Promise<void>;
     connectionType?: string | null;
     emailForOtp?: string;
     setEmailForOtp?: (email: string) => void;

package/dist/src/wagmiConfig.d.ts

@@ -9,13 +9,7 @@ import { type Chain as CoreChain } from "@abstraxn/signer-core";
  * Note: Uses 'injected' connector which automatically detects MetaMask and other wallets
  * without requiring @metamask/sdk
  */
-export declare function createWagmiConfig(chains?: CoreChain[] | Chain[], walletConnectProjectId?: string, enabledConnectors?: ("injected" | "metaMask" | "walletConnect")[], theme?: "light" | "dark", ssr?: boolean, 
-/**
- * When true, builds a wagmi config with **no** wallet connectors. Used when
- * `externalWallets.enabled` is false so hooks like `useConfig` / `useAccount`
- * still work for embedded flows without exposing MetaMask / WalletConnect.
- */
-embedOnly?: boolean): Config;
+export declare function createWagmiConfig(chains?: CoreChain[] | Chain[], walletConnectProjectId?: string, enabledConnectors?: ("injected" | "metaMask" | "walletConnect")[], theme?: "light" | "dark", ssr?: boolean): Config;
 /**
  * External wallet connector types
  */

package/dist/src/wagmiConfig.js

@@ -35,13 +35,7 @@ function convertToViemChain(chain) {
  * Note: Uses 'injected' connector which automatically detects MetaMask and other wallets
  * without requiring @metamask/sdk
  */
-export function createWagmiConfig(chains, walletConnectProjectId, enabledConnectors, theme, ssr, 
-/**
- * When true, builds a wagmi config with **no** wallet connectors. Used when
- * `externalWallets.enabled` is false so hooks like `useConfig` / `useAccount`
- * still work for embedded flows without exposing MetaMask / WalletConnect.
- */
-embedOnly) {
+export function createWagmiConfig(chains, walletConnectProjectId, enabledConnectors, theme, ssr) {
     // Normalize chains to ensure they are all valid viem Chain objects
     // This handles mixed arrays of viem Chains and CoreChains (e.g. custom chains)
     const viemChains = chains && chains.length > 0
@@ -54,28 +48,6 @@ embedOnly) {
             return convertToViemChain(chain);
         })
         : SUPPORTED_CHAINS.map(convertToViemChain);
-    // Ensure we have at least one chain (shared by embed + full config)
-    if (viemChains.length === 0) {
-        throw new Error("At least one chain is required");
-    }
-    const transports = viemChains.reduce((acc, chain) => {
-        acc[chain.id] = http();
-        return acc;
-    }, {});
-    const storage = ssr
-        ? createStorage({ storage: cookieStorage })
-        : typeof window !== "undefined"
-            ? createStorage({ storage: window.localStorage })
-            : undefined;
-    if (embedOnly) {
-        return createConfig({
-            chains: viemChains,
-            connectors: [],
-            transports,
-            storage,
-            ssr: !!ssr,
-        });
-    }
     const connectors = [];
     // Add connectors based on enabled list
     // Note: 'injected' connector will automatically detect MetaMask and other injected wallets
@@ -123,11 +95,23 @@ embedOnly) {
             }));
         }
     }
+    // Ensure we have at least one chain
+    if (viemChains.length === 0) {
+        throw new Error("At least one chain is required");
+    }
     return createConfig({
         chains: viemChains,
         connectors,
-        transports,
-        storage,
+        transports: viemChains.reduce((acc, chain) => {
+            acc[chain.id] = http();
+            return acc;
+        }, {}),
+        // Configure storage based on SSR setting
+        storage: ssr
+            ? createStorage({ storage: cookieStorage })
+            : typeof window !== "undefined"
+                ? createStorage({ storage: window.localStorage })
+                : undefined,
         ssr: !!ssr,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abstraxn/signer-react",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "description": "React SDK for Abstraxn Wallet - React components, hooks, and providers for seamless Web3 wallet integration",
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@abstraxn/signer-core": "^2.1.1",
+    "@abstraxn/signer-core": "2.1.2",
     "@solana/wallet-adapter-base": "^0.9.27",
     "@solana/wallet-adapter-react": "^0.15.39",
     "@solana/wallet-adapter-react-ui": "^0.9.39",