@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,19 @@
+export declare function useOnchainName(address: string | undefined): {
+    name: any;
+    isLoading: boolean;
+    b3Name: string | null | undefined;
+    ensName: any;
+};
+export declare function useOnchainNames(addresses: string[]): {
+    names: any[];
+    isLoading: boolean;
+};
+export declare function useResolveOnchainName(name: string | undefined): {
+    address: any;
+    isLoading: boolean;
+};
+export declare function useOnchainPFP(name: string | undefined): {
+    pfp: any;
+    isLoading: boolean;
+    address: any;
+};

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

@@ -0,0 +1,187 @@
+"use client";
+import { getB3NameByAddress, getEnsName } from "../../../shared/utils/b3Ens";
+import { fetchBsmntProfile } from "../../../shared/utils/fetchBsmntProfile";
+import { useQueries, useQuery } from "@tanstack/react-query";
+export function useOnchainName(address) {
+    const { data: bsmntName, isLoading: isLoadingBsmnt } = useQuery({
+        queryKey: ["useOnchainName/bsmntName", address?.toLowerCase()],
+        queryFn: async () => {
+            if (!address)
+                return null;
+            try {
+                const response = await fetchBsmntProfile(undefined, address);
+                return response?.username?.replaceAll(".b3.fun", "") || null;
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        enabled: !!address
+    });
+    const { data: b3Name, isLoading: isLoadingB3 } = useQuery({
+        queryKey: ["b3-name", address?.toLowerCase()],
+        queryFn: async () => {
+            if (!address)
+                return null;
+            try {
+                const response = await getB3NameByAddress(address);
+                return response?.name?.replaceAll(".b3.fun", "") || null;
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        enabled: !!address
+    });
+    const { data: ensName, isLoading: isLoadingEns } = useQuery({
+        queryKey: ["ens-name", address?.toLowerCase()],
+        queryFn: async () => {
+            if (!address)
+                return null;
+            try {
+                const corsProxyUrl = "https://proxy.basement.fun/?url=" + encodeURIComponent(`https://api.ensdata.net/${address}`);
+                const response = await fetch(corsProxyUrl);
+                const data = await response.json();
+                return data?.ens || null;
+            }
+            catch (error) {
+                console.error("Error fetching ENS name:", error);
+                return null;
+            }
+        },
+        enabled: !!address
+    });
+    return {
+        name: bsmntName || b3Name || ensName || null,
+        isLoading: isLoadingBsmnt || isLoadingB3 || isLoadingEns,
+        b3Name,
+        ensName
+    };
+}
+export function useOnchainNames(addresses) {
+    const queries = addresses.map(address => ({
+        queryKey: ["onchain-name", address.toLowerCase()],
+        queryFn: async () => {
+            try {
+                // Try B3 name first
+                const b3Response = await getB3NameByAddress(address);
+                if (b3Response?.name) {
+                    return b3Response.name;
+                }
+                // Fall back to ENS
+                const corsProxyUrl = "https://proxy.basement.fun/?url=" + encodeURIComponent(`https://api.ensdata.net/${address}`);
+                const ensResponse = await fetch(corsProxyUrl);
+                const ensData = await ensResponse.json();
+                return ensData?.ens || null;
+            }
+            catch (error) {
+                console.error("Error fetching onchain name:", error);
+                return null;
+            }
+        },
+        enabled: !!address
+    }));
+    const results = useQueries({ queries });
+    return {
+        names: results.map(result => result.data),
+        isLoading: results.some(result => result.isLoading)
+    };
+}
+// Add a new hook to resolve ENS/B3 names to addresses
+export function useResolveOnchainName(name) {
+    const { data: address, isLoading } = useQuery({
+        queryKey: ["name-resolve", name?.toLowerCase()],
+        queryFn: async () => {
+            if (!name)
+                return null;
+            try {
+                const isB3Name = name.startsWith("@") || name.toLowerCase().endsWith(".b3");
+                if (isB3Name) {
+                    // If contains and @, remove @ and add .b3.fun
+                    if (name.includes("@")) {
+                        name = name.replace("@", "").replace(".b3.fun", "") + ".b3.fun";
+                    }
+                    // Try B3 name resolution first
+                    try {
+                        const b3Response = await getEnsName(name);
+                        const b3Data = await b3Response.json();
+                        if (b3Data?.addresses?.["60"]) {
+                            return b3Data.addresses["60"];
+                        }
+                    }
+                    catch (error) { }
+                    // Fall back to ENS only if it's a .b3 name (not @)
+                    if (!name.startsWith("@")) {
+                        const corsProxyUrl = "https://proxy.basement.fun/?url=" + encodeURIComponent(`https://api.ensdata.net/${name}`);
+                        const ensResponse = await fetch(corsProxyUrl);
+                        const ensData = await ensResponse.json();
+                        return ensData?.address || null;
+                    }
+                    return null;
+                }
+                else {
+                    // Try ENS resolution first
+                    const corsProxyUrl = "https://proxy.basement.fun/?url=" + encodeURIComponent(`https://api.ensdata.net/${name}`);
+                    const ensResponse = await fetch(corsProxyUrl);
+                    const ensData = await ensResponse.json();
+                    if (ensData?.address) {
+                        return ensData.address;
+                    }
+                    // Fall back to B3 name resolution
+                    try {
+                        const b3Response = await getEnsName(name.replace("@", "").replace(".b3.fun", "").replace(".b3", "") + ".b3.fun");
+                        const b3Data = await b3Response.json();
+                        return b3Data?.addresses?.["60"] || null;
+                    }
+                    catch (error) {
+                        return null;
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error resolving name:", error);
+                return null;
+            }
+        },
+        enabled: !!name
+    });
+    return {
+        address,
+        isLoading
+    };
+}
+// Add a new hook to fetch ENS profile image
+export function useOnchainPFP(name) {
+    const { address } = useResolveOnchainName(name);
+    const { data: pfp, isLoading } = useQuery({
+        queryKey: ["ens-pfp", name?.toLowerCase()],
+        queryFn: async () => {
+            if (!name)
+                return null;
+            try {
+                // First try ENS avatar
+                const corsProxyUrl = "https://proxy.basement.fun/?url=" + encodeURIComponent(`https://api.ensdata.net/${name}`);
+                const response = await fetch(corsProxyUrl);
+                const data = await response.json();
+                if (data?.avatar) {
+                    // If it's an IPFS URL, convert it to a gateway URL
+                    if (data.avatar.startsWith("ipfs://")) {
+                        return data.avatar.replace("ipfs://", "https://ipfs.io/ipfs/");
+                    }
+                    return data.avatar;
+                }
+                return null;
+            }
+            catch (error) {
+                console.error("Error fetching ENS PFP:", error);
+                return null;
+            }
+        },
+        enabled: !!name
+    });
+    return {
+        pfp,
+        isLoading,
+        address
+    };
+}

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

@@ -0,0 +1,26 @@
+export interface Asset {
+    symbol: string;
+    name: string;
+}
+export interface ChainBalance {
+    chainId: number;
+    balance: string;
+    tokenDecimals: number;
+}
+export interface AssetBalance {
+    symbol: string;
+    name: string;
+    totalBalance: string;
+    chainBalances: ChainBalance[];
+}
+export declare const useOneBalance: (bypassCache?: boolean) => {
+    totalBalanceInEth: number;
+    totalB3BalanceInEth: number;
+    formattedTotalBalance: string;
+    aggregatedBalances: import("../../../shared/utils/fetchBalances").AssetBalance[];
+    aggregatedTokenBalances: {
+        [key: string]: number;
+    };
+    loading: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../../../shared/utils/fetchBalances").AssetBalance[], Error>>;
+};

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

@@ -0,0 +1,65 @@
+"use client";
+import { fetchBalances } from "../../../shared/utils/fetchBalances";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect, useMemo } from "react";
+import { useAccountWallet } from "./useAccountWallet";
+export const useOneBalance = (bypassCache = false) => {
+    const account = useAccountWallet();
+    const address = account?.address;
+    const sprinterTestnet = false;
+    const { data, isLoading, refetch } = useQuery({
+        queryKey: ["balances", address, `testnet-${sprinterTestnet}`],
+        queryFn: () => fetchBalances(address, sprinterTestnet),
+        enabled: !!address,
+        staleTime: 1000 * 60 * 1, // 1 minute
+        gcTime: 1000 * 60 * 5 // 5 minutes (renamed from cacheTime in v5)
+    });
+    useEffect(() => {
+        if (bypassCache) {
+            refetch();
+        }
+    }, [bypassCache, refetch]);
+    const aggregatedTokenBalances = useMemo(() => {
+        const tokenBalances = {};
+        data?.forEach(asset => {
+            const totalBalance = asset.chainBalances.reduce((sum, balance) => {
+                return sum + parseFloat(balance.balance) / Math.pow(10, balance.tokenDecimals);
+            }, 0);
+            tokenBalances[asset.symbol] = (tokenBalances[asset.symbol] || 0) + totalBalance;
+        });
+        return tokenBalances;
+    }, [data]);
+    const totalBalanceInEth = useMemo(() => {
+        return (data?.reduce((total, asset) => {
+            if (asset.symbol === "ETH" || asset.symbol === "WETH") {
+                return total + parseFloat(asset.totalBalance);
+            }
+            // TODO: Add conversion logic for other assets to ETH equivalent
+            return total;
+        }, 0) || 0);
+    }, [data]);
+    const totalB3BalanceInEth = useMemo(() => {
+        const b3Balance = data?.reduce((total, asset) => {
+            if (asset.symbol === "ETH") {
+                const b3ChainBalance = asset.chainBalances.find(balance => balance.chainId === 8333);
+                if (b3ChainBalance) {
+                    return total + parseFloat(b3ChainBalance.balance) / Math.pow(10, b3ChainBalance.tokenDecimals);
+                }
+            }
+            return total;
+        }, 0);
+        return b3Balance || 0;
+    }, [data]);
+    const formatNumber = (num) => {
+        return num.toFixed(3);
+    };
+    return {
+        totalBalanceInEth,
+        totalB3BalanceInEth,
+        formattedTotalBalance: `${formatNumber(totalBalanceInEth)} ETH`,
+        aggregatedBalances: data || [],
+        aggregatedTokenBalances,
+        loading: isLoading,
+        refetch
+    };
+};

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

@@ -0,0 +1,25 @@
+import { ServiceTypes } from "@b3dotfun/b3-api";
+import { Paginated } from "@feathersjs/feathers";
+export type ServiceMethods<T extends keyof ServiceTypes> = {
+    [M in keyof ServiceTypes[T]]: ServiceTypes[T][M] extends (...args: any[]) => any ? M : never;
+}[keyof ServiceTypes[T]];
+export type ParamsType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (...args: infer P) => any ? P[0] : never;
+type UnwrapArray<T> = T extends (infer U)[] ? U : T;
+type UnpaginatedData<T> = T extends Paginated<infer U> ? U : T;
+export type DataType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (...args: any[]) => infer R ? M extends "find" ? {
+    data: UnpaginatedData<UnwrapArray<Awaited<R>>>[];
+    total: number;
+    limit: number;
+    skip: number;
+} : Awaited<R> : never;
+export default function useQueryB3<T extends keyof ServiceTypes, // Service name (key of ServiceTypes)
+M extends ServiceMethods<T>>(service: T, // Service as string
+method: M, // Method as string
+params: ParamsType<T, M>, // Params type inferred dynamically
+fetchInitially?: boolean): {
+    data: DataType<T, M> | null;
+    error: Error | null;
+    isLoading: boolean;
+    runQuery: (queryParams: ParamsType<T, M>) => Promise<any>;
+};
+export {};

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

@@ -0,0 +1,34 @@
+import { useCallback, useEffect, useState } from "react";
+// https://feathersjs.com/guides/cli/client#usage
+import app from "../../../global-account/app";
+export default function useQueryB3(service, // Service as string
+method, // Method as string
+params, // Params type inferred dynamically
+fetchInitially = true) {
+    // Use DataType to infer the type of data and unwrap the Promise
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const runQuery = useCallback(async (queryParams) => {
+        setIsLoading(true);
+        try {
+            // Cast the service to avoid TypeScript issues with dynamic services
+            const serviceInstance = app.service(service);
+            const result = await serviceInstance[method](queryParams);
+            setData(result); // Now `data` is correctly typed!
+            return result;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error("An error occurred"));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (fetchInitially) {
+            runQuery(params);
+        }
+    }, [runQuery, fetchInitially, JSON.stringify(params)]);
+    return { data, error, isLoading, runQuery };
+}

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

@@ -0,0 +1,25 @@
+import { ServiceTypes } from "@b3dotfun/basement-api";
+import { Paginated } from "@feathersjs/feathers";
+export type ServiceMethods<T extends keyof ServiceTypes> = {
+    [M in keyof ServiceTypes[T]]: ServiceTypes[T][M] extends (...args: any[]) => any ? M : never;
+}[keyof ServiceTypes[T]];
+export type ParamsType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (...args: infer P) => any ? P[0] : never;
+type UnwrapArray<T> = T extends (infer U)[] ? U : T;
+type UnpaginatedData<T> = T extends Paginated<infer U> ? U : T;
+export type DataType<T extends keyof ServiceTypes, M extends ServiceMethods<T>> = ServiceTypes[T][M] extends (...args: any[]) => infer R ? M extends "find" ? {
+    data: UnpaginatedData<UnwrapArray<Awaited<R>>>[];
+    total: number;
+    limit: number;
+    skip: number;
+} : Awaited<R> : never;
+export default function useQueryBSMNT<T extends keyof ServiceTypes, // Service name (key of ServiceTypes)
+M extends ServiceMethods<T>>(service: T, // Service as string
+method: M, // Method as string
+params: ParamsType<T, M>, // Params type inferred dynamically
+fetchInitially?: boolean): {
+    data: DataType<T, M> | null;
+    error: Error | null;
+    isLoading: boolean;
+    runQuery: (queryParams: ParamsType<T, M>) => Promise<any>;
+};
+export {};

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

@@ -0,0 +1,34 @@
+import { useCallback, useEffect, useState } from "react";
+// https://feathersjs.com/guides/cli/client#usage
+import app from "../../../global-account/bsmnt";
+export default function useQueryBSMNT(service, // Service as string
+method, // Method as string
+params, // Params type inferred dynamically
+fetchInitially = true) {
+    // Use DataType to infer the type of data and unwrap the Promise
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const runQuery = useCallback(async (queryParams) => {
+        setIsLoading(true);
+        try {
+            // Cast the service to avoid TypeScript issues with dynamic services
+            const serviceInstance = app.service(service);
+            const result = await serviceInstance[method](queryParams);
+            setData(result); // Now `data` is correctly typed!
+            return result;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error("An error occurred"));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (fetchInitially) {
+            runQuery(params);
+        }
+    }, [runQuery, fetchInitially, JSON.stringify(params)]);
+    return { data, error, isLoading, runQuery };
+}

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

@@ -0,0 +1,16 @@
+import { ActiveSigners } from "../../../global-account/types";
+import { Chain, Hex, ThirdwebClient } from "thirdweb";
+export declare function useRemoveSessionKey({ onSuccess, onError, refetchSigners, chain }: {
+    chain?: Chain;
+    onSuccess: (transactionResult: {
+        transactionHash: Hex;
+    } & {
+        client: ThirdwebClient;
+        chain: Chain;
+    }) => void;
+    onError: (error: Error) => void;
+    refetchSigners: () => Promise<any>;
+}): {
+    removeSessionKey: (signer: ActiveSigners[number]) => Promise<void>;
+    isRemovingSessionKey: boolean;
+};

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

@@ -0,0 +1,43 @@
+import { client } from "../../../shared/utils/thirdweb";
+import createDebug from "debug";
+import { useCallback, useState } from "react";
+import { sendTransaction } from "thirdweb";
+import { removeSessionKey } from "thirdweb/extensions/erc4337";
+import { useActiveAccount } from "thirdweb/react";
+const debug = createDebug("@@b3:useHandleTWConnect");
+export function useRemoveSessionKey({ onSuccess, onError, refetchSigners, chain }) {
+    const [isRemovingSessionKey, setIsRemovingSessionKey] = useState(false);
+    if (!chain) {
+        throw new Error("Chain is required");
+    }
+    const account = useActiveAccount();
+    const removeSessionKeyHandler = useCallback(async (signer) => {
+        if (!account || !chain)
+            return;
+        setIsRemovingSessionKey(true);
+        try {
+            const transaction = removeSessionKey({
+                contract: {
+                    client,
+                    chain,
+                    address: account.address
+                },
+                account,
+                sessionKeyAddress: signer.signer
+            });
+            debug("@@ecosystem:removeSessionKey:transaction:", transaction);
+            const transactionResult = await sendTransaction({ transaction, account });
+            debug("@@ecosystem:removeSessionKey:transactionResult:", transactionResult);
+            onSuccess(transactionResult);
+            await refetchSigners();
+        }
+        catch (error) {
+            onError(error);
+            console.error("@@ecosystem:removeSessionKey:error:", error);
+        }
+        finally {
+            setIsRemovingSessionKey(false);
+        }
+    }, [account, chain, onSuccess, onError, refetchSigners]);
+    return { removeSessionKey: removeSessionKeyHandler, isRemovingSessionKey };
+}

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

@@ -0,0 +1,14 @@
+interface UseRouterReturn {
+    pathname: string;
+    search: string;
+    hash: string;
+    push: (url: string) => void;
+    replace: (url: string) => void;
+    back: () => void;
+    forward: () => void;
+}
+/**
+ * A router hook that works with both client-side and server-side rendering
+ */
+export declare function useRouter(): UseRouterReturn;
+export default useRouter;

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

@@ -0,0 +1,75 @@
+// We intentionally disable the hooks rules here because we need to conditionally return early for SSR.
+// This is safe in this context because the hook is only used in environments where window is defined.
+/* eslint-disable react-hooks/rules-of-hooks */
+import { useCallback, useEffect, useState } from "react";
+/**
+ * A router hook that works with both client-side and server-side rendering
+ */
+export function useRouter() {
+    // For SSR, return dummy implementation
+    if (typeof window === "undefined") {
+        return {
+            pathname: "",
+            search: "",
+            hash: "",
+            push: () => { },
+            replace: () => { },
+            back: () => { },
+            forward: () => { }
+        };
+    }
+    // Initialize state with current location
+    const [routerState, setRouterState] = useState(() => ({
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    }));
+    // Update state when location changes
+    useEffect(() => {
+        const handleLocationChange = () => {
+            setRouterState({
+                pathname: window.location.pathname,
+                search: window.location.search,
+                hash: window.location.hash
+            });
+        };
+        // Listen for popstate event (browser back/forward)
+        window.addEventListener("popstate", handleLocationChange);
+        return () => {
+            window.removeEventListener("popstate", handleLocationChange);
+        };
+    }, []);
+    // Navigation methods
+    const push = useCallback((url) => {
+        window.history.pushState({}, "", url);
+        // Manually trigger state update since pushState doesn't fire popstate
+        setRouterState({
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash
+        });
+    }, []);
+    const replace = useCallback((url) => {
+        window.history.replaceState({}, "", url);
+        // Manually trigger state update
+        setRouterState({
+            pathname: window.location.pathname,
+            search: window.location.search,
+            hash: window.location.hash
+        });
+    }, []);
+    const back = useCallback(() => {
+        window.history.back();
+    }, []);
+    const forward = useCallback(() => {
+        window.history.forward();
+    }, []);
+    return {
+        ...routerState,
+        push,
+        replace,
+        back,
+        forward
+    };
+}
+export default useRouter;

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

@@ -0,0 +1,2 @@
+export default function useSearchParamsSSR(): URLSearchParams;
+export declare function useSearchParam(param: string): string | null;

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

@@ -0,0 +1,27 @@
+"use client";
+import { useCallback, useEffect, useState } from "react";
+export default function useSearchParamsSSR() {
+    const [searchParams, setSearchParams] = useState(() => {
+        if (typeof window === "undefined") {
+            return new URLSearchParams();
+        }
+        return new URLSearchParams(window.location.search);
+    });
+    // Use callback to read from window to avoid Suspense
+    const updateSearchParams = useCallback(() => {
+        if (typeof window !== "undefined") {
+            setSearchParams(new URLSearchParams(window.location.search));
+        }
+    }, []);
+    useEffect(() => {
+        updateSearchParams();
+        // Optional: Update on popstate
+        window.addEventListener("popstate", updateSearchParams);
+        return () => window.removeEventListener("popstate", updateSearchParams);
+    }, [updateSearchParams]);
+    return searchParams;
+}
+export function useSearchParam(param) {
+    const searchParams = useSearchParamsSSR();
+    return searchParams.get(param);
+}

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

@@ -0,0 +1,4 @@
+import { Account } from "thirdweb/wallets";
+export declare function useSiwe(): {
+    authenticate: (account: Account) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+};

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

@@ -0,0 +1,32 @@
+import app from "../../../global-account/app";
+import debug from "../../../shared/utils/debug";
+import { useCallback } from "react";
+export function useSiwe() {
+    const authenticate = useCallback(async (account) => {
+        if (!account || !account.signMessage)
+            throw new Error("Account not found");
+        // generate challenge
+        const challenge = await app.service("global-accounts-challenge").create({
+            address: account.address
+        });
+        debug("@@useAuthenticate:challenge", challenge);
+        // sign challenge
+        const signature = await account.signMessage({
+            message: challenge.message
+        });
+        debug("@@useAuthenticate:signature", signature);
+        // authenticate
+        const response = await app.authenticate({
+            strategy: "smart-account-siwe",
+            message: challenge.message,
+            signature,
+            serverSignature: challenge.serverSignature,
+            nonce: challenge.nonce
+        });
+        debug("@@useAuthenticate:response", response);
+        return response;
+    }, []);
+    return {
+        authenticate
+    };
+}

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

@@ -0,0 +1,12 @@
+import { Token } from "../../../anyspend";
+interface UseTokenBalanceProps {
+    token: Token;
+    address?: string;
+}
+export interface TokenBalanceResult {
+    rawBalance: bigint | null;
+    formattedBalance: string;
+    isLoading: boolean;
+}
+export declare function useTokenBalance({ token, address }: UseTokenBalanceProps): TokenBalanceResult;
+export {};