@openfort/react 0.3.1 → 1.0.0

package/build/ethereum/hooks/useEthereumEmbeddedWallet.js

@@ -0,0 +1,425 @@
+import { ChainTypeEnum, AccountTypeEnum, EmbeddedState, RecoveryMethod } from '@openfort/openfort-js';
+import { useRef, useState, useMemo, useCallback, useEffect } from 'react';
+import { baseSepolia } from 'viem/chains';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { useConnectionStrategy } from '../../core/ConnectionStrategyContext.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useOpenfortCore } from '../../openfort/useOpenfort.js';
+import { buildEmbeddedWalletStatusResult } from '../../shared/utils/embeddedWalletStatusMapper.js';
+import { buildRecoveryParams } from '../../shared/utils/recovery.js';
+import { toConnectedStateProperties } from '../../shared/utils/walletStatusProps.js';
+import { formatAddress } from '../../utils/format.js';
+
+/** Base Sepolia — fallback chain when no strategy or config provides a chain ID. */
+const DEFAULT_TESTNET_CHAIN_ID = baseSepolia.id;
+function buildConnectedWallet(acc, index, getProvider, overrides) {
+    var _a, _b, _c;
+    return {
+        id: acc.id,
+        address: acc.address,
+        ownerAddress: acc.ownerAddress,
+        implementationType: acc.implementationType,
+        chainType: ChainTypeEnum.EVM,
+        walletIndex: index,
+        recoveryMethod: acc.recoveryMethod,
+        getProvider: (_a = overrides === null || overrides === void 0 ? void 0 : overrides.getProvider) !== null && _a !== void 0 ? _a : getProvider,
+        isAvailable: true,
+        isActive: (_b = overrides === null || overrides === void 0 ? void 0 : overrides.isActive) !== null && _b !== void 0 ? _b : false,
+        isConnecting: (_c = overrides === null || overrides === void 0 ? void 0 : overrides.isConnecting) !== null && _c !== void 0 ? _c : false,
+        accounts: [{ id: acc.id, chainId: acc.chainId }],
+        connectorType: 'embedded',
+        walletClientType: 'openfort',
+        accountId: acc.id,
+        accountType: acc.accountType,
+        createdAt: acc.createdAt,
+        salt: acc.salt,
+    };
+}
+/**
+ * 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] })
+ * }
+ * ```
+ */
+function useEthereumEmbeddedWallet(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const { client, embeddedAccounts, embeddedState, isLoadingAccounts, updateEmbeddedAccounts, setActiveEmbeddedAddress, setWalletStatus, activeEmbeddedAddress, } = useOpenfortCore();
+    const { walletConfig, chainType } = useOpenfort();
+    const strategy = useConnectionStrategy();
+    const creationChainId = (_b = (_a = options === null || options === void 0 ? void 0 : options.chainId) !== null && _a !== void 0 ? _a : strategy === null || strategy === void 0 ? void 0 : strategy.getChainId()) !== null && _b !== void 0 ? _b : DEFAULT_TESTNET_CHAIN_ID;
+    const activeReturnChainId = (_c = strategy === null || strategy === void 0 ? void 0 : strategy.getChainId()) !== null && _c !== void 0 ? _c : DEFAULT_TESTNET_CHAIN_ID;
+    const setActiveInProgressRef = useRef(null);
+    const ethereumAccountsRef = useRef([]);
+    const [state, setState] = useState({
+        status: 'disconnected',
+        activeWallet: null,
+        provider: null,
+        error: null,
+    });
+    const ethereumAccounts = useMemo(() => {
+        if (!embeddedAccounts)
+            return [];
+        return embeddedAccounts.filter((acc) => acc.chainType === ChainTypeEnum.EVM);
+    }, [embeddedAccounts]);
+    ethereumAccountsRef.current = ethereumAccounts;
+    const getEmbeddedEthereumProvider = useCallback(async () => {
+        const provider = await client.embeddedWallet.getEthereumProvider();
+        // Ensure the current account is authorized on the provider.
+        // Without this, signing after password recovery can fail with
+        // "Unauthorized - call eth_requestAccounts first" because the provider
+        // was obtained before initProvider ran with proper config.
+        await provider.request({ method: 'eth_requestAccounts' });
+        return provider;
+    }, [client]);
+    const wallets = useMemo(() => {
+        var _a;
+        const uniqueAddresses = new Map();
+        for (const acc of ethereumAccounts) {
+            const key = acc.address.toLowerCase();
+            if (!uniqueAddresses.has(key)) {
+                uniqueAddresses.set(key, acc);
+            }
+        }
+        const activeAddr = (_a = state.activeWallet) === null || _a === void 0 ? void 0 : _a.address.toLowerCase();
+        const isConnecting = state.status === 'connecting' || state.status === 'reconnecting';
+        return Array.from(uniqueAddresses.values()).map((acc, index) => {
+            const addr = acc.address.toLowerCase();
+            return buildConnectedWallet(acc, index, getEmbeddedEthereumProvider, {
+                isActive: state.status === 'connected' && activeAddr === addr,
+                isConnecting: isConnecting && activeAddr === addr,
+            });
+        });
+    }, [ethereumAccounts, getEmbeddedEthereumProvider, state.status, state.activeWallet]);
+    useEffect(() => {
+        if (state.status === 'creating') {
+            setWalletStatus({ status: 'creating' });
+        }
+        else if (state.status === 'connecting' && state.activeWallet) {
+            setWalletStatus({ status: 'connecting', address: state.activeWallet.address });
+        }
+        else {
+            setWalletStatus({ status: 'idle' });
+        }
+    }, [state.status, (_d = state.activeWallet) === null || _d === void 0 ? void 0 : _d.address, setWalletStatus]);
+    const create = useCallback(async (createOptions) => {
+        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: createOptions === null || createOptions === void 0 ? void 0 : createOptions.recoveryMethod,
+                passkeyId: createOptions === null || createOptions === void 0 ? void 0 : createOptions.passkeyId,
+                password: createOptions === null || createOptions === void 0 ? void 0 : createOptions.password,
+                otpCode: createOptions === null || createOptions === void 0 ? void 0 : createOptions.otpCode,
+            }, {
+                walletConfig,
+                getAccessToken: () => client.getAccessToken(),
+                getUserId: async () => {
+                    const user = await client.user.get();
+                    return user === null || user === void 0 ? void 0 : user.id;
+                },
+            });
+            // Determine account type (use createOptions, then walletConfig, else default to Smart Account)
+            const accountType = (_c = (_a = createOptions === null || createOptions === void 0 ? void 0 : createOptions.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 : AccountTypeEnum.SMART_ACCOUNT;
+            const account = await client.embeddedWallet.create({
+                chainType: ChainTypeEnum.EVM,
+                accountType,
+                ...(accountType !== AccountTypeEnum.EOA && { chainId: (_d = createOptions === null || createOptions === void 0 ? void 0 : createOptions.chainId) !== null && _d !== void 0 ? _d : creationChainId }),
+                recoveryParams,
+            });
+            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,
+            });
+            setActiveEmbeddedAddress(account.address);
+            (_e = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onSuccess) === null || _e === void 0 ? void 0 : _e.call(createOptions, { account });
+            return account;
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to create Ethereum wallet', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            setState((s) => ({
+                ...s,
+                status: 'error',
+                error: error.message,
+            }));
+            (_f = createOptions === null || createOptions === void 0 ? void 0 : createOptions.onError) === null || _f === void 0 ? void 0 : _f.call(createOptions, error);
+            throw error;
+        }
+    }, [
+        client,
+        walletConfig,
+        creationChainId,
+        getEmbeddedEthereumProvider,
+        updateEmbeddedAccounts,
+        setActiveEmbeddedAddress,
+    ]);
+    const setActive = useCallback(async (activeOptions) => {
+        const run = async () => {
+            var _a, _b, _c, _d, _e;
+            const accounts = ethereumAccountsRef.current;
+            const account = accounts.find((acc) => acc.address.toLowerCase() === activeOptions.address.toLowerCase());
+            if (!account) {
+                throw new OpenfortError('Embedded wallet not found', OpenfortReactErrorType.WALLET_ERROR, {
+                    address: activeOptions.address,
+                });
+            }
+            const connectingStub = buildConnectedWallet(account, accounts.indexOf(account), getEmbeddedEthereumProvider, {
+                isActive: false,
+                isConnecting: true,
+                getProvider: async () => {
+                    throw new OpenfortError('Provider not ready yet', OpenfortReactErrorType.WALLET_ERROR);
+                },
+            });
+            setState((s) => ({ ...s, status: 'connecting', activeWallet: connectingStub, error: null }));
+            try {
+                const password = activeOptions.password;
+                const hasExplicitRecovery = activeOptions.recoveryParams != null || password != null || activeOptions.recoveryMethod !== undefined;
+                let recoveryParams = activeOptions.recoveryParams;
+                if (!recoveryParams && !hasExplicitRecovery) {
+                    if (account.recoveryMethod === RecoveryMethod.PASSKEY) {
+                        const passkeyId = (_a = activeOptions.passkeyId) !== null && _a !== void 0 ? _a : (_b = account.recoveryMethodDetails) === null || _b === void 0 ? void 0 : _b.passkeyId;
+                        recoveryParams = {
+                            recoveryMethod: RecoveryMethod.PASSKEY,
+                            ...(passkeyId && { passkeyInfo: { passkeyId } }),
+                        };
+                    }
+                    else if (account.recoveryMethod === RecoveryMethod.PASSWORD) {
+                        setState((s) => ({ ...s, status: 'needs-recovery', error: null }));
+                        return;
+                    }
+                    else {
+                        recoveryParams = await buildRecoveryParams({ recoveryMethod: undefined, otpCode: activeOptions.otpCode }, {
+                            walletConfig,
+                            getAccessToken: () => client.getAccessToken(),
+                            getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
+                        });
+                    }
+                }
+                else if (!recoveryParams && hasExplicitRecovery) {
+                    recoveryParams = await buildRecoveryParams({
+                        recoveryMethod: (_c = activeOptions.recoveryMethod) !== null && _c !== void 0 ? _c : (password != null ? RecoveryMethod.PASSWORD : undefined),
+                        passkeyId: (_d = activeOptions.passkeyId) !== null && _d !== void 0 ? _d : (_e = account.recoveryMethodDetails) === null || _e === void 0 ? void 0 : _e.passkeyId,
+                        password,
+                        otpCode: activeOptions.otpCode,
+                    }, {
+                        walletConfig,
+                        getAccessToken: () => client.getAccessToken(),
+                        getUserId: async () => { var _a; return (_a = (await client.user.get())) === null || _a === void 0 ? void 0 : _a.id; },
+                    });
+                }
+                if (recoveryParams) {
+                    await client.embeddedWallet.recover({
+                        account: account.id,
+                        recoveryParams,
+                    });
+                }
+                const provider = await getEmbeddedEthereumProvider();
+                const connectedWallet = buildConnectedWallet(account, accounts.indexOf(account), async () => provider, {
+                    isActive: true,
+                    isConnecting: false,
+                });
+                setState({
+                    status: 'connected',
+                    activeWallet: connectedWallet,
+                    provider,
+                    error: null,
+                });
+                setActiveEmbeddedAddress(account.address);
+            }
+            catch (err) {
+                const error = err instanceof OpenfortError
+                    ? err
+                    : new OpenfortError('Failed to set active Ethereum wallet', OpenfortReactErrorType.WALLET_ERROR, {
+                        error: err,
+                    });
+                setState((s) => ({
+                    ...s,
+                    status: 'error',
+                    error: error.message,
+                }));
+                throw error;
+            }
+        };
+        const prev = setActiveInProgressRef.current;
+        if (prev) {
+            try {
+                await prev;
+            }
+            catch {
+                /* ignore previous operation's error */
+            }
+        }
+        const promise = run();
+        setActiveInProgressRef.current = promise;
+        try {
+            await promise;
+        }
+        finally {
+            if (setActiveInProgressRef.current === promise)
+                setActiveInProgressRef.current = null;
+        }
+    }, [client, walletConfig, getEmbeddedEthereumProvider, setActiveEmbeddedAddress]);
+    const setRecovery = useCallback(async (recoveryOptions) => {
+        try {
+            await client.embeddedWallet.setRecoveryMethod(recoveryOptions.previousRecovery, recoveryOptions.newRecovery);
+            await updateEmbeddedAccounts({ silent: true });
+        }
+        catch (err) {
+            const error = err instanceof OpenfortError
+                ? err
+                : new OpenfortError('Failed to set recovery method', OpenfortReactErrorType.WALLET_ERROR, { error: err });
+            throw error;
+        }
+    }, [client, updateEmbeddedAccounts]);
+    const exportPrivateKey = useCallback(async () => {
+        return await client.embeddedWallet.exportPrivateKey();
+    }, [client]);
+    const actions = useMemo(() => ({
+        create,
+        wallets,
+        setActive,
+        setRecovery,
+        exportPrivateKey,
+    }), [create, wallets, setActive, setRecovery, exportPrivateKey]);
+    // Use refs for values that should NOT re-trigger the sync effect.
+    const stateRef = useRef(state);
+    stateRef.current = state;
+    // Prevents the sync effect from firing multiple async getProvider calls concurrently.
+    const syncInProgressRef = useRef(null);
+    // Sync local state from core's activeEmbeddedAddress (single source of truth).
+    // Only re-runs when the three meaningful inputs change: activeEmbeddedAddress, embeddedState, accounts list.
+    useEffect(() => {
+        var _a;
+        const s = stateRef.current;
+        // Not ready to sync yet
+        if (isLoadingAccounts || ethereumAccounts.length === 0 || embeddedState !== EmbeddedState.READY) {
+            // Clear state if address was removed (logout) while we're in a connected state
+            if (!activeEmbeddedAddress && (s.status === 'connected' || s.status === 'needs-recovery')) {
+                setState({ status: 'disconnected', activeWallet: null, provider: null, error: null });
+            }
+            return;
+        }
+        // Don't interrupt in-progress operations
+        if (s.status === 'connecting' || s.status === 'reconnecting' || s.status === 'creating') {
+            return;
+        }
+        // Logout / address cleared
+        if (!activeEmbeddedAddress && s.status === 'connected') {
+            setState({ status: 'disconnected', activeWallet: null, provider: null, error: null });
+            return;
+        }
+        // Find matching account
+        const accountByAddress = activeEmbeddedAddress
+            ? ethereumAccounts.find((acc) => acc.address.toLowerCase() === activeEmbeddedAddress.toLowerCase())
+            : undefined;
+        // Already synced to the right address
+        if (s.status === 'connected' && ((_a = s.activeWallet) === null || _a === void 0 ? void 0 : _a.address.toLowerCase()) === (activeEmbeddedAddress === null || activeEmbeddedAddress === void 0 ? void 0 : activeEmbeddedAddress.toLowerCase())) {
+            return;
+        }
+        // Activate the matching account
+        if (accountByAddress) {
+            // Already syncing this address — skip duplicate async work
+            if (syncInProgressRef.current === accountByAddress.address.toLowerCase()) {
+                return;
+            }
+            syncInProgressRef.current = accountByAddress.address.toLowerCase();
+            let cancelled = false;
+            getEmbeddedEthereumProvider()
+                .then((provider) => {
+                if (cancelled)
+                    return;
+                const connectedWallet = buildConnectedWallet(accountByAddress, ethereumAccounts.indexOf(accountByAddress), async () => provider, { isActive: true, isConnecting: false });
+                setState({ status: 'connected', activeWallet: connectedWallet, provider, error: null });
+            })
+                .catch(() => { })
+                .finally(() => {
+                if (!cancelled)
+                    syncInProgressRef.current = null;
+            });
+            return () => {
+                cancelled = true;
+                syncInProgressRef.current = null;
+            };
+        }
+        // activeEmbeddedAddress is from another chain (e.g. SVM); auto-activate first EVM wallet.
+        // Also fires from 'error': if setActive failed and address still points to a SVM wallet,
+        // re-point to the EVM wallet so the sync can self-heal.
+        if (chainType === ChainTypeEnum.EVM &&
+            activeEmbeddedAddress &&
+            ethereumAccounts.length > 0 &&
+            (s.status === 'disconnected' || s.status === 'error')) {
+            setActiveEmbeddedAddress(ethereumAccounts[0].address);
+        }
+    }, [
+        activeEmbeddedAddress,
+        embeddedState,
+        ethereumAccounts,
+        isLoadingAccounts,
+        chainType,
+        getEmbeddedEthereumProvider,
+        setActiveEmbeddedAddress,
+    ]);
+    const derived = useMemo(() => ({
+        isLoading: state.status === 'fetching-wallets' ||
+            state.status === 'connecting' ||
+            state.status === 'creating' ||
+            state.status === 'reconnecting',
+        isError: state.status === 'error',
+        isSuccess: state.status === 'connected',
+    }), [state.status]);
+    const connectedStateProps = useMemo(() => toConnectedStateProperties(state.status, state.activeWallet), [state.status, state.activeWallet]);
+    // Compute displayAddress when connected
+    const displayAddress = useMemo(() => {
+        var _a;
+        return ((_a = state.activeWallet) === null || _a === void 0 ? void 0 : _a.address) && (state.status === 'connected' || state.status === 'connecting')
+            ? formatAddress(state.activeWallet.address, ChainTypeEnum.EVM)
+            : undefined;
+    }, [(_e = state.activeWallet) === null || _e === void 0 ? void 0 : _e.address, state.status]);
+    if (isLoadingAccounts) {
+        return {
+            ...actions,
+            status: 'fetching-wallets',
+            activeWallet: null,
+            isLoading: true,
+            isError: false,
+            isSuccess: false,
+            embeddedWalletId: undefined,
+            isConnected: false,
+            isConnecting: true,
+            isDisconnected: false,
+            isReconnecting: false,
+        };
+    }
+    return {
+        ...buildEmbeddedWalletStatusResult(state, actions),
+        ...derived,
+        ...connectedStateProps,
+        ...(displayAddress && { displayAddress }),
+        ...(((_f = state.activeWallet) === null || _f === void 0 ? void 0 : _f.address) && { address: state.activeWallet.address }),
+        chainId: activeReturnChainId,
+    };
+}
+
+export { useEthereumEmbeddedWallet };
+//# sourceMappingURL=useEthereumEmbeddedWallet.js.map

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

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

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

@@ -0,0 +1,29 @@
+import type { Asset } from '../../components/Openfort/types';
+import { OpenfortError } from '../../core/errors';
+import type { EthereumConfig } from '../../ethereum/types';
+type UseEthereumWalletAssetsOptions = {
+    assets?: EthereumConfig['assets'];
+    staleTime?: number;
+};
+/**
+ * Returns wallet assets (tokens, NFTs) for the connected Ethereum address.
+ * Uses ERC-7811 via Openfort's authenticated RPC proxy.
+ *
+ * @param options - Optional custom assets config and staleTime
+ * @returns assets, isLoading, error, refetch
+ *
+ * @example
+ * ```tsx
+ * const { data: assets, isLoading } = useEthereumWalletAssets()
+ * ```
+ */
+export declare const useEthereumWalletAssets: ({ assets: hookCustomAssets, staleTime, }?: UseEthereumWalletAssetsOptions) => {
+    data: readonly Asset[] | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    isIdle: boolean;
+    error: OpenfortError | undefined;
+    refetch: () => Promise<readonly Asset[] | undefined>;
+};
+export {};

package/build/ethereum/hooks/useEthereumWalletAssets.js

@@ -0,0 +1,204 @@
+import { useCallback, useMemo } from 'react';
+import { custom, createWalletClient, numberToHex } from 'viem';
+import { erc7811Actions } from 'viem/experimental';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../types.js';
+import { useUser } from '../../hooks/openfort/useUser.js';
+import { openfortKeys } from '../../query/queryKeys.js';
+import { useAsyncData } from '../../shared/hooks/useAsyncData.js';
+import { useEthereumEmbeddedWallet } from './useEthereumEmbeddedWallet.js';
+
+/**
+ * Returns wallet assets (tokens, NFTs) for the connected Ethereum address.
+ * Uses ERC-7811 via Openfort's authenticated RPC proxy.
+ *
+ * @param options - Optional custom assets config and staleTime
+ * @returns assets, isLoading, error, refetch
+ *
+ * @example
+ * ```tsx
+ * const { data: assets, isLoading } = useEthereumWalletAssets()
+ * ```
+ */
+const useEthereumWalletAssets = ({ assets: hookCustomAssets, staleTime = 30000, } = {}) => {
+    var _a;
+    const wallet = useEthereumEmbeddedWallet();
+    const isConnected = wallet.status === 'connected';
+    const address = isConnected ? wallet.address : undefined;
+    const chainId = isConnected ? wallet.chainId : undefined;
+    const { walletConfig, publishableKey, overrides, thirdPartyAuth, chains } = useOpenfort();
+    const { getAccessToken } = useUser();
+    const chain = chains.find((c) => c.id === chainId);
+    const buildHeaders = useCallback(async () => {
+        if (thirdPartyAuth) {
+            const accessToken = await thirdPartyAuth.getAccessToken();
+            if (!accessToken) {
+                throw new OpenfortError('Failed to get access token from third party auth provider', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-auth-provider': thirdPartyAuth.provider,
+                'x-player-token': accessToken,
+                'x-token-type': 'idToken',
+                Authorization: `Bearer ${publishableKey}`,
+            };
+            return headers;
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-project-key': publishableKey,
+            Authorization: `Bearer ${await getAccessToken()}`,
+        };
+        return headers;
+    }, [publishableKey, getAccessToken, thirdPartyAuth]);
+    const customTransport = useMemo(() => () => {
+        return custom({
+            async request({ method, params }) {
+                const res = await fetch(`${(overrides === null || overrides === void 0 ? void 0 : overrides.backendUrl) || 'https://api.openfort.io'}/rpc`, {
+                    method: 'POST',
+                    headers: await buildHeaders(),
+                    body: JSON.stringify({
+                        method,
+                        params: params[0],
+                        id: 1,
+                        jsonrpc: '2.0',
+                    }),
+                });
+                const data = await res.json();
+                if (data.error) {
+                    throw new Error(data.error.message);
+                }
+                return data.result;
+            },
+        });
+    }, [buildHeaders, overrides === null || overrides === void 0 ? void 0 : overrides.backendUrl]);
+    const customAssetsToFetch = useMemo(() => {
+        var _a;
+        if (!chainId)
+            return [];
+        const assetsFromConfig = ((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets) ? walletConfig.ethereum.assets[chainId] || [] : [];
+        const assetsFromHook = hookCustomAssets ? hookCustomAssets[chainId] || [] : [];
+        const allAssets = [...assetsFromConfig, ...assetsFromHook];
+        return allAssets;
+    }, [(_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets, hookCustomAssets, chainId]);
+    const { data, error, isLoading, refetch } = useAsyncData({
+        queryKey: [...openfortKeys.walletAssets(chainId, customAssetsToFetch, address)],
+        queryFn: async () => {
+            var _a, _b, _c, _d;
+            if (!address || !chainId || !chain) {
+                throw new OpenfortError('Wallet not connected', OpenfortReactErrorType.UNEXPECTED_ERROR, {
+                    error: new Error('Address, chainId, or chain not available'),
+                });
+            }
+            const customClient = createWalletClient({
+                account: address,
+                chain,
+                transport: customTransport(),
+            });
+            const extendedClient = customClient.extend(erc7811Actions());
+            const defaultAssetsPromise = extendedClient.getAssets({
+                chainIds: [chainId],
+            });
+            const hexChainId = numberToHex(chainId);
+            const customAssetsPromise = customAssetsToFetch.length > 0
+                ? extendedClient.getAssets({
+                    chainIds: [chainId],
+                    assets: {
+                        [hexChainId]: customAssetsToFetch.map((a) => ({
+                            address: a,
+                            type: 'erc20',
+                        })),
+                    },
+                })
+                : Promise.resolve({ [hexChainId]: [] });
+            const [defaultAssetsRaw, customAssets] = await Promise.all([defaultAssetsPromise, customAssetsPromise]);
+            // ERC-7811 response keys may be hex (e.g. "0x14a34") or numeric depending on the RPC
+            const rawByChain = defaultAssetsRaw;
+            const customByChain = customAssets;
+            const rawChainAssets = (_b = (_a = rawByChain[hexChainId]) !== null && _a !== void 0 ? _a : rawByChain[String(chainId)]) !== null && _b !== void 0 ? _b : [];
+            const customChainAssets = (_d = (_c = customByChain[hexChainId]) !== null && _c !== void 0 ? _c : customByChain[String(chainId)]) !== null && _d !== void 0 ? _d : [];
+            const defaultAssets = rawChainAssets.map((a) => {
+                var _a;
+                let asset;
+                if (a.type === 'erc20') {
+                    const meta = a.metadata;
+                    asset = {
+                        type: 'erc20',
+                        address: a.address,
+                        balance: a.balance,
+                        metadata: {
+                            name: (meta === null || meta === void 0 ? void 0 : meta.name) || 'Unknown Token',
+                            symbol: (meta === null || meta === void 0 ? void 0 : meta.symbol) || 'UNKNOWN',
+                            decimals: meta === null || meta === void 0 ? void 0 : meta.decimals,
+                            fiat: meta === null || meta === void 0 ? void 0 : meta.fiat,
+                        },
+                        raw: a,
+                    };
+                }
+                else if (a.type === 'native') {
+                    const meta = a.metadata;
+                    asset = {
+                        type: 'native',
+                        address: 'native',
+                        balance: a.balance,
+                        metadata: (meta === null || meta === void 0 ? void 0 : meta.fiat) ? { symbol: (_a = meta.symbol) !== null && _a !== void 0 ? _a : '', decimals: meta.decimals, fiat: meta.fiat } : undefined,
+                        raw: a,
+                    };
+                }
+                else {
+                    throw new OpenfortError('Unsupported asset type', OpenfortReactErrorType.UNEXPECTED_ERROR, { error: a });
+                }
+                return asset;
+            });
+            const mergedAssets = [...defaultAssets];
+            const customAssetsForChain = customChainAssets.flatMap((asset) => {
+                var _a, _b;
+                // Custom assets are explicitly requested as erc20; skip if the API returns something unexpected.
+                if (asset.type !== 'erc20')
+                    return [];
+                if (!((_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.assets))
+                    return [{ ...asset, raw: asset }];
+                const configAsset = (_b = walletConfig.ethereum.assets[chainId]) === null || _b === void 0 ? void 0 : _b.find((a) => a.toLowerCase() === asset.address.toLowerCase());
+                if (!configAsset)
+                    return [{ ...asset, raw: asset }];
+                return [
+                    {
+                        type: 'erc20',
+                        address: asset.address,
+                        balance: asset.balance,
+                        metadata: asset.metadata,
+                        raw: asset,
+                    },
+                ];
+            });
+            customAssetsForChain.forEach((asset) => {
+                if (!mergedAssets.find((a) => a.address === asset.address)) {
+                    mergedAssets.push(asset);
+                }
+            });
+            return mergedAssets;
+        },
+        enabled: isConnected && !!chainId && !!chain && !!address,
+        staleTime,
+    });
+    const mappedError = useMemo(() => {
+        if (!error)
+            return undefined;
+        if (error instanceof OpenfortError) {
+            return error;
+        }
+        return new OpenfortError('Failed to fetch wallet assets', OpenfortReactErrorType.UNEXPECTED_ERROR, { error });
+    }, [error]);
+    return {
+        data: data !== null && data !== void 0 ? data : null,
+        isLoading,
+        isError: !!error,
+        isSuccess: !!data && !error,
+        isIdle: !isConnected || !chainId || !chain,
+        error: mappedError,
+        refetch,
+    };
+};
+
+export { useEthereumWalletAssets };
+//# sourceMappingURL=useEthereumWalletAssets.js.map

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

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