@b3dotfun/sdk 0.0.1-alpha.1

package/dist/esm/global-account/react/hooks/useBsmntProfile.d.ts

@@ -0,0 +1,4 @@
+export interface UseProfileOptions {
+    address?: string;
+}
+export declare const useBsmntProfile: ({ address }: UseProfileOptions) => import("@tanstack/react-query").UseQueryResult<any, Error>;

package/dist/esm/global-account/react/hooks/useBsmntProfile.js

@@ -0,0 +1,9 @@
+import { fetchBsmntProfile } from "../../../shared/utils/fetchBsmntProfile";
+import { useQuery } from "@tanstack/react-query";
+export const useBsmntProfile = ({ address }) => {
+    return useQuery({
+        queryKey: ["useBsmntProfile", address],
+        queryFn: () => fetchBsmntProfile(undefined, address),
+        enabled: !!address
+    });
+};

package/dist/esm/global-account/react/hooks/useChainSwitchWithAction.d.ts

@@ -0,0 +1,5 @@
+import { WalletClient } from "viem";
+export declare function useChainSwitchWithAction(): {
+    switchChainAndExecute: (targetChainId: number, action: (client: WalletClient) => Promise<void>) => Promise<void>;
+    isSwitchingOrExecuting: boolean;
+};

package/dist/esm/global-account/react/hooks/useChainSwitchWithAction.js

@@ -0,0 +1,70 @@
+import { getChainName, getNativeToken } from "../../../anyspend";
+import { supportedChains } from "../../../shared/constants/chains/supported";
+import { invariant } from "framer-motion";
+import { useCallback, useState } from "react";
+import { toast } from "sonner";
+import { useSwitchChain, useWalletClient } from "wagmi";
+export function useChainSwitchWithAction() {
+    const { data: walletClient } = useWalletClient();
+    const { switchChainAsync } = useSwitchChain();
+    const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
+    const run = useCallback(async (fn) => {
+        try {
+            setIsSwitchingOrExecuting(true);
+            await fn();
+        }
+        catch (err) {
+            console.error(err);
+            toast.error(err?.message ?? "Unexpected error");
+        }
+        finally {
+            setIsSwitchingOrExecuting(false);
+        }
+    }, []);
+    const switchChainAndExecute = useCallback(async (targetChainId, action) => {
+        if (!walletClient) {
+            toast.error("Please connect your wallet");
+            return;
+        }
+        const providerId = walletClient.chain.id;
+        const onCorrectChain = providerId === targetChainId;
+        if (onCorrectChain) {
+            return run(() => action(walletClient));
+        }
+        toast.info(`Switching to ${getChainName(targetChainId)}…`);
+        const targetChain = supportedChains.find(chain => chain.id === targetChainId);
+        if (!targetChain) {
+            toast.error(`Chain ${targetChainId} is not supported`);
+            return;
+        }
+        try {
+            invariant(!!targetChain.blockExplorers?.default.url, "Block explorer URL is required");
+            const nativeCurrency = getNativeToken(targetChainId);
+            await switchChainAsync({
+                chainId: targetChainId,
+                addEthereumChainParameter: {
+                    chainName: targetChain.name,
+                    rpcUrls: [targetChain.rpcUrls.default.http[0]],
+                    blockExplorerUrls: [targetChain.blockExplorers?.default.url],
+                    nativeCurrency: {
+                        name: nativeCurrency.name,
+                        symbol: nativeCurrency.symbol,
+                        decimals: nativeCurrency.decimals
+                    }
+                }
+            });
+            await run(() => action(walletClient));
+        }
+        catch (e) {
+            if (e?.code === -32603 || e?.message?.includes("f is not a function")) {
+                // This is a workaround for a bug in the wallet provider.
+                toast(`Switched to ${getChainName(targetChainId)}. Executing…`);
+                await switchChainAndExecute(targetChainId, action);
+            }
+            else {
+                toast.error(e?.message ?? "Unexpected error");
+            }
+        }
+    }, [walletClient, run, switchChainAsync]);
+    return { switchChainAndExecute, isSwitchingOrExecuting };
+}

package/dist/esm/global-account/react/hooks/useClaim.d.ts

@@ -0,0 +1,16 @@
+import { Chain } from "thirdweb";
+import { Account } from "thirdweb/wallets";
+interface UseClaimProps {
+    contractAddress: string;
+    quantity?: number;
+    chain: Chain;
+    to: string;
+    tokenId?: number;
+}
+export declare function useClaim({ contractAddress, quantity, chain, to, tokenId }: UseClaimProps): {
+    claim: (account: Account) => Promise<`0x${string}`>;
+    isMinting: boolean;
+};
+export declare const useClaim721: typeof useClaim;
+export declare const useClaim1155: typeof useClaim;
+export {};

package/dist/esm/global-account/react/hooks/useClaim.js

@@ -0,0 +1,46 @@
+import { client } from "../../../shared/utils/thirdweb";
+import { useCallback, useState } from "react";
+import { getContract, sendTransaction } from "thirdweb";
+import { claimTo as claimTo1155 } from "thirdweb/extensions/erc1155";
+import { claimTo as claimTo721 } from "thirdweb/extensions/erc721";
+export function useClaim({ contractAddress, quantity = 1, chain, to, tokenId }) {
+    const [isMinting, setIsMinting] = useState(false);
+    const claim = useCallback(async (account) => {
+        if (!to) {
+            throw new Error("No recipient address provided");
+        }
+        setIsMinting(true);
+        try {
+            const contract = getContract({
+                client,
+                chain,
+                address: contractAddress
+            });
+            // If tokenId is provided, use ERC1155 claim
+            const transaction = tokenId !== undefined
+                ? claimTo1155({
+                    contract,
+                    to,
+                    quantity: BigInt(quantity),
+                    tokenId: BigInt(tokenId)
+                })
+                : claimTo721({
+                    contract,
+                    to,
+                    quantity: BigInt(quantity)
+                });
+            const tx = await sendTransaction({
+                transaction,
+                account
+            });
+            return tx.transactionHash;
+        }
+        finally {
+            setIsMinting(false);
+        }
+    }, [contractAddress, quantity, chain, to, tokenId]);
+    return { claim, isMinting };
+}
+// Export both for backward compatibility
+export const useClaim721 = useClaim;
+export const useClaim1155 = useClaim;

package/dist/esm/global-account/react/hooks/useConnect.d.ts

@@ -0,0 +1,9 @@
+import { Chain } from "thirdweb";
+import { SingleStepAuthArgsType } from "thirdweb/wallets";
+/**
+ * This hook is used to connect to a wallet using the thirdweb client.
+ */
+export declare function useConnect(partnerId: string, chain?: Chain): {
+    connect: (strategyOptions?: SingleStepAuthArgsType) => Promise<import("thirdweb/wallets").Wallet | null>;
+    isLoading: boolean;
+};

package/dist/esm/global-account/react/hooks/useConnect.js

@@ -0,0 +1,49 @@
+import { ecosystemWalletId, THIRDWEB_CLIENT_ID } from "../../../shared/constants";
+import { debugB3React } from "../../../shared/utils/debug";
+import { client } from "../../../shared/utils/thirdweb";
+import { useCallback, useState } from "react";
+import { useConnect as useConnectTW } from "thirdweb/react";
+import { ecosystemWallet } from "thirdweb/wallets";
+const debug = debugB3React("useConnect");
+/**
+ * This hook is used to connect to a wallet using the thirdweb client.
+ */
+export function useConnect(partnerId, chain) {
+    if (!chain) {
+        throw new Error("Chain is required");
+    }
+    const { connect } = useConnectTW();
+    const [isLoading, setIsLoading] = useState(false);
+    /**
+     * This is a wrapper around the thirdweb connect function.
+     * It is used to connect to a wallet using the thirdweb client.
+     */
+    const connectTw = useCallback(async (strategyOptions) => {
+        setIsLoading(true);
+        return await connect(async () => {
+            if (!strategyOptions)
+                throw new Error("Strategy options are required");
+            debug("@@useConnect:strategyOptions", {
+                partnerId,
+                strategyOptions,
+                clientId: THIRDWEB_CLIENT_ID
+            });
+            // Create a wallet for "Allowlist" ecosystems restricted to partners
+            const wallet = ecosystemWallet(ecosystemWalletId, {
+                partnerId: partnerId
+            });
+            const connect = await wallet.connect({
+                client,
+                chain,
+                // This is the payload that is sent to the auth endpoint
+                ...strategyOptions
+            });
+            debug("@@useConnect:connect:", connect);
+            setIsLoading(false);
+            if (!wallet)
+                throw new Error("Failed to connect");
+            return wallet;
+        });
+    }, [chain, connect, partnerId]);
+    return { connect: connectTw, isLoading };
+}

package/dist/esm/global-account/react/hooks/useExchangeRate.d.ts

@@ -0,0 +1,12 @@
+interface UseExchangeRateProps {
+    baseCurrency: string;
+    quoteCurrency: string;
+    refreshInterval?: number;
+}
+export declare function useExchangeRate({ baseCurrency, quoteCurrency, refreshInterval }: UseExchangeRateProps): {
+    rate: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<number, Error>>;
+};
+export default useExchangeRate;

package/dist/esm/global-account/react/hooks/useExchangeRate.js

@@ -0,0 +1,27 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+async function fetchExchangeRate(baseCurrency, quoteCurrency) {
+    const response = await fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${baseCurrency}`);
+    if (!response.ok) {
+        throw new Error("Failed to fetch exchange rate");
+    }
+    const data = await response.json();
+    return parseFloat(data.data.rates[quoteCurrency]);
+}
+export function useExchangeRate({ baseCurrency, quoteCurrency, refreshInterval = 30000 }) {
+    const { data: rate = 0, isLoading, error, refetch } = useQuery({
+        queryKey: ["exchangeRate", baseCurrency, quoteCurrency],
+        queryFn: () => fetchExchangeRate(baseCurrency, quoteCurrency),
+        refetchInterval: refreshInterval,
+        staleTime: refreshInterval / 2, // Consider data stale after half the refresh interval
+        retry: 3,
+        retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, 30000)
+    });
+    return {
+        rate,
+        isLoading,
+        error,
+        refetch
+    };
+}
+export default useExchangeRate;

package/dist/esm/global-account/react/hooks/useGetAllTWSigners.d.ts

@@ -0,0 +1,30 @@
+import { Signer } from "../../../global-account/types";
+import { UseQueryOptions } from "@tanstack/react-query";
+import { Chain } from "thirdweb";
+interface UseGetAllTWSignersProps {
+    chain?: Chain;
+    accountAddress?: string;
+    queryOptions?: Partial<UseQueryOptions<TWSignerWithMetadata[], Error>>;
+}
+export interface TWSignerWithMetadata extends Signer {
+    id: string;
+    partner: {
+        name: string;
+        id: string;
+        description?: string;
+        website?: string;
+        icon?: string;
+    };
+    metadata: {
+        ecosystemId?: string;
+        timestamp: number;
+        permissionStartTimestamp: number;
+        permissionEndTimestamp: number;
+        approvedTargets: string[];
+    };
+    createdAt: string;
+    endTimestamp: bigint;
+    nativeTokenLimitPerTransaction: bigint;
+}
+export declare function useGetAllTWSigners({ chain, accountAddress, queryOptions }: UseGetAllTWSignersProps): import("@tanstack/react-query").UseQueryResult<TWSignerWithMetadata[], Error>;
+export {};

package/dist/esm/global-account/react/hooks/useGetAllTWSigners.js

@@ -0,0 +1,71 @@
+import { client } from "../../../shared/utils/thirdweb";
+import { useQuery } from "@tanstack/react-query";
+import createDebug from "debug";
+import { getAllActiveSigners } from "thirdweb/extensions/erc4337";
+const debug = createDebug("@@b3:useGetAllTWSigners");
+export function useGetAllTWSigners({ chain, accountAddress, queryOptions }) {
+    return useQuery({
+        ...queryOptions,
+        queryKey: ["useGetAllTWSigners", chain?.id, accountAddress],
+        queryFn: async () => {
+            if (!chain || !accountAddress) {
+                return [];
+            }
+            debug("@@getAllActiveSigners:start");
+            const signers = await getAllActiveSigners({
+                contract: {
+                    client,
+                    chain,
+                    address: accountAddress
+                }
+            });
+            // Wait half a second for the sync, this is a hack
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // Fetch metadata from our worker
+            let sessionKeysMetadata = {};
+            try {
+                const response = await fetch(`https://partner-session-keys-production.sean-430.workers.dev/?address=${accountAddress}&timestamp=${Date.now()}`, {
+                    method: "GET",
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+                if (response.ok) {
+                    const data = (await response.json());
+                    sessionKeysMetadata = data.keys.reduce((acc, key) => {
+                        acc[key.sessionKey] = key;
+                        return acc;
+                    }, {});
+                }
+            }
+            catch (error) {
+                debug("Error fetching session keys metadata:", error);
+            }
+            // If no signers, return empty array
+            if (!signers || !Array.isArray(signers) || signers.length === 0) {
+                debug("@@useGetAllTWSigners:no signers");
+                return [];
+            }
+            // Transform and combine the data
+            const result = signers.map(signer => {
+                const metadata = sessionKeysMetadata[signer.signer];
+                return {
+                    ...signer,
+                    id: signer.signer,
+                    metadata,
+                    partner: {
+                        id: metadata?.partnerId || signer.signer,
+                        name: metadata?.partnerInfo?.name || ""
+                    },
+                    createdAt: metadata ? new Date(metadata.timestamp).toISOString() : ""
+                };
+            });
+            return result;
+        },
+        enabled: Boolean(chain && accountAddress),
+        refetchOnMount: true,
+        refetchOnWindowFocus: true,
+        refetchOnReconnect: true,
+        staleTime: 0 // Consider data stale immediately
+    });
+}

package/dist/esm/global-account/react/hooks/useGetGeo.d.ts

@@ -0,0 +1,17 @@
+interface GeoData {
+    country: string;
+    city: string;
+    ip: string;
+    continent: string;
+    latitude: string;
+    longitude: string;
+    region: string;
+    regionCode: string;
+    timezone: string;
+}
+declare function useGetGeo(): {
+    geoData: GeoData | undefined;
+    loading: boolean;
+    error: Error | null;
+};
+export default useGetGeo;

package/dist/esm/global-account/react/hooks/useGetGeo.js

@@ -0,0 +1,18 @@
+"use client";
+import { debug } from "../../../shared/utils/debug";
+import { useQuery } from "@tanstack/react-query";
+async function fetchGeoData() {
+    const response = await fetch("https://geo.basement.fun/");
+    if (!response.ok) {
+        throw new Error("Failed to fetch geo data");
+    }
+    return response.json();
+}
+function useGetGeo() {
+    const { data: geoData, isLoading: loading, error } = useQuery({ queryKey: ["useGetGeo"], queryFn: fetchGeoData, retry: 3 });
+    if (error) {
+        debug("@@useGetGeo error fetching geo data", error);
+    }
+    return { geoData, loading, error };
+}
+export default useGetGeo;

package/dist/esm/global-account/react/hooks/useHandleConnectWithPrivy.d.ts

@@ -0,0 +1,11 @@
+import { Chain } from "thirdweb";
+import { Account } from "thirdweb/wallets";
+/**
+ * This essentially wraps our useConnect hook to handle the Privy auth flow.
+ * Currently, this is for the basement-privy strategy
+ */
+export declare function useHandleConnectWithPrivy(partnerId: string, chain?: Chain, onSuccess?: (account: Account) => void): {
+    connectTw: () => Promise<import("thirdweb/wallets").Wallet | null | undefined>;
+    isLoading: boolean;
+    fullToken: string | null;
+};

package/dist/esm/global-account/react/hooks/useHandleConnectWithPrivy.js

@@ -0,0 +1,66 @@
+import { useConnect } from "../../../global-account/react/hooks/useConnect";
+import { debugB3React } from "../../../shared/utils/debug";
+import { useIdentityToken, usePrivy } from "@privy-io/react-auth";
+import { useCallback, useRef, useState } from "react";
+const debug = debugB3React("@@b3:useHandleConnectWithPrivy");
+/**
+ * This essentially wraps our useConnect hook to handle the Privy auth flow.
+ * Currently, this is for the basement-privy strategy
+ */
+export function useHandleConnectWithPrivy(partnerId, chain, onSuccess) {
+    if (!chain) {
+        throw new Error("Chain is required");
+    }
+    const { connect } = useConnect(partnerId, chain);
+    const [isLoading, setIsLoading] = useState(true);
+    const isConnecting = useRef(false);
+    const { identityToken } = useIdentityToken();
+    const { getAccessToken } = usePrivy();
+    const [fullToken, setFullToken] = useState(null);
+    const connectTw = useCallback(async () => {
+        if (isConnecting.current) {
+            debug("@@connectTw:skipping:isConnecting", isConnecting.current);
+            return;
+        }
+        setIsLoading(true);
+        isConnecting.current = true;
+        // Form token
+        const accessToken = await getAccessToken();
+        const fullToken = `${accessToken}+${identityToken}`;
+        setFullToken(fullToken);
+        debug("@@connectTw:fullToken", fullToken);
+        if (!fullToken)
+            throw new Error("Token is not set");
+        // Connect to TW via privy
+        const wallet = await connect({
+            strategy: "auth_endpoint",
+            payload: JSON.stringify({
+                strategy: "basement",
+                accessToken: fullToken
+            })
+        });
+        debug("@@useHandleConnectWithPrivy:connect:return", wallet);
+        setIsLoading(false);
+        // Handle onsuccess & more
+        try {
+            debug("@@autoLogin:starting", fullToken);
+            const account = wallet?.getAccount();
+            if (!account) {
+                throw new Error("Failed to connect");
+            }
+            onSuccess?.(account);
+            if (!account) {
+                throw new Error("Failed to connect");
+            }
+        }
+        catch (error) {
+            console.error("@@Error signing in with Privy", error);
+        }
+        finally {
+            isConnecting.current = false;
+            setIsLoading(false);
+        }
+        return wallet;
+    }, [connect, getAccessToken, identityToken, onSuccess]);
+    return { connectTw, isLoading, fullToken };
+}

package/dist/esm/global-account/react/hooks/useHasMounted.d.ts

@@ -0,0 +1 @@
+export declare function useHasMounted(): boolean;

package/dist/esm/global-account/react/hooks/useHasMounted.js

@@ -0,0 +1,8 @@
+import { useEffect, useState } from "react";
+export function useHasMounted() {
+    const [hasMounted, setHasMounted] = useState(false);
+    useEffect(() => {
+        setHasMounted(true);
+    }, []);
+    return hasMounted;
+}

package/dist/esm/global-account/react/hooks/useIsMobile.d.ts

@@ -0,0 +1,2 @@
+declare const useIsMobile: () => boolean;
+export default useIsMobile;

package/dist/esm/global-account/react/hooks/useIsMobile.js

@@ -0,0 +1,6 @@
+"use client";
+import { useMediaQuery } from "./useMediaQuery";
+const useIsMobile = () => {
+    return useMediaQuery("(max-width: 767px)");
+};
+export default useIsMobile;

package/dist/esm/global-account/react/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/esm/global-account/react/hooks/useIsomorphicLayoutEffect.js

@@ -0,0 +1,2 @@
+import { useEffect, useLayoutEffect } from "react";
+export const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;

package/dist/esm/global-account/react/hooks/useMediaQuery.d.ts

@@ -0,0 +1,6 @@
+type UseMediaQueryOptions = {
+    defaultValue?: boolean;
+    initializeWithValue?: boolean;
+};
+export declare function useMediaQuery(query: string, { defaultValue, initializeWithValue }?: UseMediaQueryOptions): boolean;
+export {};

package/dist/esm/global-account/react/hooks/useMediaQuery.js

@@ -0,0 +1,44 @@
+"use client";
+//https://usehooks-ts.com/react-hook/use-media-query
+import { useState } from "react";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect";
+const IS_SERVER = typeof window === "undefined";
+export function useMediaQuery(query, { defaultValue = false, initializeWithValue = true } = {}) {
+    const getMatches = (query) => {
+        if (IS_SERVER) {
+            return defaultValue;
+        }
+        return window.matchMedia(query).matches;
+    };
+    const [matches, setMatches] = useState(() => {
+        if (initializeWithValue) {
+            return getMatches(query);
+        }
+        return defaultValue;
+    });
+    // Handles the change event of the media query.
+    function handleChange() {
+        setMatches(getMatches(query));
+    }
+    useIsomorphicLayoutEffect(() => {
+        const matchMedia = window.matchMedia(query);
+        // Triggered at the first client-side load and if query changes
+        handleChange();
+        // Use deprecated `addListener` and `removeListener` to support Safari < 14 (#135)
+        if (matchMedia.addListener) {
+            matchMedia.addListener(handleChange);
+        }
+        else {
+            matchMedia.addEventListener("change", handleChange);
+        }
+        return () => {
+            if (matchMedia.removeListener) {
+                matchMedia.removeListener(handleChange);
+            }
+            else {
+                matchMedia.removeEventListener("change", handleChange);
+            }
+        };
+    }, [query]);
+    return matches;
+}

package/dist/esm/global-account/react/hooks/useNativeBalance.d.ts

@@ -0,0 +1,22 @@
+export declare function useNativeBalance(address?: string, chainIds?: string): import("@tanstack/react-query").UseQueryResult<{
+    total: number;
+    formattedTotal: string;
+    breakdown: {
+        chainId: number;
+        balance: bigint;
+        formatted: string;
+    }[];
+}, Error>;
+/**
+ * Fetches the native balance of an address from the RPC
+ *
+ * @param address - The address to fetch the balance of
+ * @param chainId - The chain ID to fetch the balance from
+ * @returns The native balance of the address
+ *
+ * TODO: Deprecate Ethers, this is the only thing depending on it
+ */
+export declare function useNativeBalanceFromRPC(address: string, chainId: number): {
+    balance: number;
+    isLoading: boolean;
+};

package/dist/esm/global-account/react/hooks/useNativeBalance.js

@@ -0,0 +1,72 @@
+import { b3Mainnet, b3Testnet } from "../../../shared/constants/chains/supported";
+import { formatNumber } from "../../../shared/utils/formatNumber";
+import { useQuery } from "@tanstack/react-query";
+import { toast } from "sonner";
+import { createPublicClient, formatEther, formatUnits, http } from "viem";
+async function fetchNativeBalance(address, chainIds) {
+    if (!address)
+        throw new Error("Address is required");
+    const response = await fetch(`https://api.sprinter.buildwithsygma.com/accounts/${address}/assets/native?whitelistedChains=${chainIds}`);
+    if (!response.ok) {
+        throw new Error("Failed to fetch native balance");
+    }
+    const data = await response.json();
+    // Calculate total balance in ETH across all chains
+    const total = data.data.reduce((acc, curr) => {
+        const balance = formatUnits(BigInt(curr.balance), curr.tokenDecimals);
+        return acc + Number(balance);
+    }, 0);
+    return {
+        total,
+        formattedTotal: formatNumber(total),
+        breakdown: data.data.map(item => ({
+            chainId: item.chainId,
+            balance: BigInt(item.balance),
+            formatted: formatNumber(Number(formatUnits(BigInt(item.balance), item.tokenDecimals)))
+        }))
+    };
+}
+export function useNativeBalance(address, chainIds = "8333") {
+    return useQuery({
+        queryKey: ["nativeBalance", address, chainIds],
+        queryFn: () => fetchNativeBalance(address, chainIds),
+        enabled: Boolean(address),
+        staleTime: 30 * 1000, // Consider data fresh for 30 seconds
+        gcTime: 5 * 60 * 1000 // Keep unused data in cache for 5 minutes
+    });
+}
+/**
+ * Fetches the native balance of an address from the RPC
+ *
+ * @param address - The address to fetch the balance of
+ * @param chainId - The chain ID to fetch the balance from
+ * @returns The native balance of the address
+ *
+ * TODO: Deprecate Ethers, this is the only thing depending on it
+ */
+export function useNativeBalanceFromRPC(address, chainId) {
+    const { data: balance = 0, isLoading } = useQuery({
+        queryKey: ["nativeBalanceRPC", address, chainId],
+        queryFn: async () => {
+            if (!address)
+                return 0;
+            try {
+                const publicClient = createPublicClient({
+                    chain: chainId === 8333 ? b3Mainnet : b3Testnet,
+                    transport: http()
+                });
+                const balance = await publicClient.getBalance({
+                    address: address
+                });
+                return parseFloat(formatEther(balance));
+            }
+            catch (error) {
+                console.error("Error fetching balance:", error);
+                toast.error("Failed to fetch wallet balance");
+                return 0;
+            }
+        },
+        enabled: Boolean(address)
+    });
+    return { balance, isLoading };
+}