@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,78 @@
+"use strict";
+// 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 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRouter = useRouter;
+const react_1 = require("react");
+/**
+ * A router hook that works with both client-side and server-side rendering
+ */
+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] = (0, react_1.useState)(() => ({
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    }));
+    // Update state when location changes
+    (0, react_1.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 = (0, react_1.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 = (0, react_1.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 = (0, react_1.useCallback)(() => {
+        window.history.back();
+    }, []);
+    const forward = (0, react_1.useCallback)(() => {
+        window.history.forward();
+    }, []);
+    return {
+        ...routerState,
+        push,
+        replace,
+        back,
+        forward
+    };
+}
+exports.default = useRouter;

package/dist/cjs/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/cjs/global-account/react/hooks/useSearchParamsSSR.js

@@ -0,0 +1,31 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = useSearchParamsSSR;
+exports.useSearchParam = useSearchParam;
+const react_1 = require("react");
+function useSearchParamsSSR() {
+    const [searchParams, setSearchParams] = (0, react_1.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 = (0, react_1.useCallback)(() => {
+        if (typeof window !== "undefined") {
+            setSearchParams(new URLSearchParams(window.location.search));
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        updateSearchParams();
+        // Optional: Update on popstate
+        window.addEventListener("popstate", updateSearchParams);
+        return () => window.removeEventListener("popstate", updateSearchParams);
+    }, [updateSearchParams]);
+    return searchParams;
+}
+function useSearchParam(param) {
+    const searchParams = useSearchParamsSSR();
+    return searchParams.get(param);
+}

package/dist/cjs/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/cjs/global-account/react/hooks/useSiwe.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSiwe = useSiwe;
+const app_1 = __importDefault(require("../../../global-account/app"));
+const debug_1 = __importDefault(require("../../../shared/utils/debug"));
+const react_1 = require("react");
+function useSiwe() {
+    const authenticate = (0, react_1.useCallback)(async (account) => {
+        if (!account || !account.signMessage)
+            throw new Error("Account not found");
+        // generate challenge
+        const challenge = await app_1.default.service("global-accounts-challenge").create({
+            address: account.address
+        });
+        (0, debug_1.default)("@@useAuthenticate:challenge", challenge);
+        // sign challenge
+        const signature = await account.signMessage({
+            message: challenge.message
+        });
+        (0, debug_1.default)("@@useAuthenticate:signature", signature);
+        // authenticate
+        const response = await app_1.default.authenticate({
+            strategy: "smart-account-siwe",
+            message: challenge.message,
+            signature,
+            serverSignature: challenge.serverSignature,
+            nonce: challenge.nonce
+        });
+        (0, debug_1.default)("@@useAuthenticate:response", response);
+        return response;
+    }, []);
+    return {
+        authenticate
+    };
+}

package/dist/cjs/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 {};

package/dist/cjs/global-account/react/hooks/useTokenBalance.js

@@ -0,0 +1,64 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenBalance = useTokenBalance;
+const anyspend_1 = require("../../../anyspend");
+const global_account_1 = require("../../../global-account");
+const useAccountWallet_1 = require("../../../global-account/react/hooks/useAccountWallet");
+const number_1 = require("../../../shared/utils/number");
+const thirdweb_insights_1 = require("../../../shared/utils/thirdweb-insights");
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+function useTokenBalance({ token, address }) {
+    const { ready } = (0, global_account_1.useB3)();
+    const account = (0, useAccountWallet_1.useAccountWallet)();
+    const effectiveAddress = address || account?.address;
+    const { data: tokenBalance, isLoading, isFetching, refetch } = (0, react_query_1.useQuery)({
+        queryKey: ["tokenBalance", effectiveAddress, token.chainId, token.address],
+        queryFn: async () => {
+            if (!effectiveAddress)
+                return { formatted: "0", raw: null };
+            if ((0, anyspend_1.isNativeToken)(token.address)) {
+                const nativeToken = await (0, thirdweb_insights_1.getNativeTokenBalance)(effectiveAddress, token.chainId);
+                if (nativeToken && nativeToken.balance) {
+                    const rawBalance = nativeToken.balance;
+                    return {
+                        formatted: (0, number_1.formatTokenAmount)(BigInt(rawBalance), Number(nativeToken.decimals || 18)),
+                        raw: BigInt(rawBalance)
+                    };
+                }
+                return { formatted: "0", raw: null };
+            }
+            const response = await (0, thirdweb_insights_1.getERC20Balances)(effectiveAddress, {
+                chainIds: [token.chainId],
+                includeSpam: false
+            });
+            const tokenBalance = response.data?.find(t => t.token_address === token.address);
+            if (tokenBalance?.balance) {
+                return {
+                    formatted: (0, number_1.formatTokenAmount)(BigInt(tokenBalance.balance), Number(tokenBalance.decimals || 18)),
+                    raw: BigInt(tokenBalance.balance)
+                };
+            }
+            return { formatted: "0", raw: null };
+        },
+        enabled: ready && !!effectiveAddress,
+        staleTime: 30000,
+        gcTime: 5 * 60 * 1000,
+        retry: 2,
+        structuralSharing: false
+    });
+    // Force a refetch when the wallet or token changes
+    (0, react_1.useEffect)(() => {
+        if (ready && effectiveAddress) {
+            refetch();
+        }
+    }, [ready, effectiveAddress, token.address, token.chainId, token.symbol, refetch]);
+    // Determine if we're actually loading
+    const isActuallyLoading = !ready || !effectiveAddress || isLoading || (isFetching && !tokenBalance);
+    return {
+        rawBalance: tokenBalance?.raw || 0n,
+        formattedBalance: tokenBalance?.formatted || "0",
+        isLoading: isActuallyLoading
+    };
+}

package/dist/cjs/global-account/react/hooks/useTokenBalancesByChain.d.ts

@@ -0,0 +1,22 @@
+import { TokenData } from "../../../shared/utils/thirdweb-insights";
+type GetWalletBalanceResult = {
+    value: bigint;
+    decimals: number;
+    displayValue: string;
+    symbol: string;
+    name: string;
+    chainId: number;
+};
+export interface TokenBalancesByChain {
+    nativeTokens: GetWalletBalanceResult[];
+    fungibleTokens: TokenData[];
+    isLoading: boolean;
+    error: Error | null;
+}
+interface UseTokenBalancesByChainProps {
+    address: string;
+    chainsIds: number | number[];
+    enabled?: boolean;
+}
+export declare function useTokenBalancesByChain({ address, chainsIds, enabled }: UseTokenBalancesByChainProps): TokenBalancesByChain;
+export {};

package/dist/cjs/global-account/react/hooks/useTokenBalancesByChain.js

@@ -0,0 +1,58 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenBalancesByChain = useTokenBalancesByChain;
+const thirdweb_insights_1 = require("../../../shared/utils/thirdweb-insights");
+const react_query_1 = require("@tanstack/react-query");
+const b3Chain_1 = require("../../../shared/constants/chains/b3Chain");
+const chains_1 = require("../../../shared/utils/chains");
+const thirdweb_1 = require("../../../shared/utils/thirdweb");
+const wallets_1 = require("thirdweb/wallets");
+function useTokenBalancesByChain({ address, chainsIds, enabled = true }) {
+    // Normalize chains to array
+    const chainIds = Array.isArray(chainsIds) ? chainsIds : [chainsIds];
+    const { data: combinedData, isLoading, error } = (0, react_query_1.useQuery)({
+        queryKey: ["tokenBalancesByChain", address, chainIds.join(",")],
+        queryFn: async () => {
+            try {
+                // Run both fetches in parallel
+                const [nativeTokens, fungibleResponse] = await Promise.all([
+                    // Fetch native token balances
+                    Promise.all(chainIds.map(async (chainId) => {
+                        const walletBalance = await (0, wallets_1.getWalletBalance)({
+                            address,
+                            client: thirdweb_1.client,
+                            chain: (0, b3Chain_1.viemToThirdwebChain)((0, chains_1.getChainById)(chainId))
+                        });
+                        return {
+                            chainId,
+                            ...walletBalance
+                        };
+                    })),
+                    (0, thirdweb_insights_1.getERC20Balances)(address, {
+                        chainIds
+                    })
+                ]);
+                return {
+                    nativeTokens,
+                    fungibleTokens: fungibleResponse.data
+                };
+            }
+            catch (err) {
+                console.error("Error fetching token balances:", err);
+                throw err;
+            }
+        },
+        enabled: enabled && !!address && chainIds.length > 0,
+        staleTime: 30000, // Consider data fresh for 30 seconds
+        gcTime: 5 * 60 * 1000, // Keep in cache for 5 minutes
+        retry: 2, // Limit retries on failure
+        structuralSharing: false
+    });
+    return {
+        nativeTokens: combinedData?.nativeTokens ?? [],
+        fungibleTokens: combinedData?.fungibleTokens ?? [],
+        isLoading,
+        error: error
+    };
+}

package/dist/cjs/global-account/react/hooks/useTokenData.d.ts

@@ -0,0 +1,9 @@
+export interface TokenResponse {
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+}
+export declare function useTokenData(chainId?: number, address?: string): import("@tanstack/react-query").UseQueryResult<TokenResponse | null, Error>;

package/dist/cjs/global-account/react/hooks/useTokenData.js

@@ -0,0 +1,47 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenData = useTokenData;
+const react_query_1 = require("@tanstack/react-query");
+function useTokenData(chainId, address) {
+    return (0, react_query_1.useQuery)({
+        queryKey: ["tokenData", chainId, address?.toLowerCase()],
+        queryFn: async () => {
+            try {
+                if (!chainId || !address || address.trim() === "")
+                    return null;
+                const normalizedAddress = address.toLowerCase();
+                // Call B3 API - now includes Relay API fallback on the backend
+                try {
+                    const response = await fetch("https://api.b3.fun/tokens", {
+                        method: "POST",
+                        headers: {
+                            "X-Service-Method": "findByAddress",
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({ chainId, address: normalizedAddress })
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data)
+                            return data;
+                    }
+                }
+                catch (e) {
+                    console.error("Error fetching token data:", e);
+                }
+                return null;
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        staleTime: 60 * 1000, // 1 minute
+        gcTime: 10 * 60 * 1000, // 10 minutes
+        retry: 1,
+        enabled: Boolean(chainId) && Boolean(address) && address?.trim() !== "",
+        refetchOnWindowFocus: false,
+        refetchOnMount: false,
+        refetchOnReconnect: false
+    });
+}

package/dist/cjs/global-account/react/hooks/useTokenFromUrl.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "../../../anyspend";
+interface UseTokenFromUrlOptions {
+    /**
+     * Default token to use when URL params are not available
+     */
+    defaultToken: Token;
+    /**
+     * The URL parameter prefix to look for (e.g., "from" or "to")
+     */
+    prefix: string;
+}
+/**
+ * Hook to parse token data from URL parameters.
+ * Looks for parameters: [prefix]Currency
+ */
+export declare function useTokenFromUrl({ defaultToken, prefix }: UseTokenFromUrlOptions): Token;
+export {};

package/dist/cjs/global-account/react/hooks/useTokenFromUrl.js

@@ -0,0 +1,30 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenFromUrl = useTokenFromUrl;
+const navigation_1 = require("next/navigation");
+/**
+ * Hook to parse token data from URL parameters.
+ * Looks for parameters: [prefix]Currency
+ */
+function useTokenFromUrl({ defaultToken, prefix }) {
+    const searchParams = (0, navigation_1.useSearchParams)();
+    if (!searchParams) {
+        return defaultToken;
+    }
+    // Get parameters from URL
+    const currencyParam = searchParams.get(`${prefix}Currency`);
+    const chainIdParam = searchParams.get(`${prefix}ChainId`);
+    if (!currencyParam || !chainIdParam) {
+        return defaultToken;
+    }
+    // If the currency is the same as the default token, return that
+    if (currencyParam.toLowerCase() === defaultToken.address.toLowerCase()) {
+        return defaultToken;
+    }
+    return {
+        ...defaultToken,
+        address: currencyParam,
+        chainId: Number(chainIdParam)
+    };
+}

package/dist/cjs/global-account/react/hooks/useTokenPrice.d.ts

@@ -0,0 +1,17 @@
+import { type ChainId } from "../../../shared/constants/chains/chainPlatformMap";
+import { type UseQueryOptions } from "@tanstack/react-query";
+interface UseTokenPriceProps {
+    contractAddress: string;
+    chainId?: ChainId;
+    vsCurrency?: string;
+    refreshInterval?: number;
+    queryOptions?: Omit<UseQueryOptions<number, Error>, "queryKey" | "queryFn" | "refetchInterval" | "staleTime" | "retry" | "retryDelay">;
+}
+export declare function useTokenPrice({ contractAddress, chainId, // Default to Base
+vsCurrency, refreshInterval, queryOptions }: UseTokenPriceProps): {
+    price: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<number, Error>>;
+};
+export default useTokenPrice;

package/dist/cjs/global-account/react/hooks/useTokenPrice.js

@@ -0,0 +1,48 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokenPrice = useTokenPrice;
+const chainPlatformMap_1 = require("../../../shared/constants/chains/chainPlatformMap");
+const react_query_1 = require("@tanstack/react-query");
+async function fetchTokenPrice(contractAddress, chainId, vsCurrency = "usd") {
+    const platformId = (0, chainPlatformMap_1.getPlatformId)(chainId);
+    const response = await fetch(`https://pro-api.coingecko.com/api/v3/simple/token_price/${platformId}?contract_addresses=${contractAddress}&vs_currencies=${vsCurrency}`, {
+        headers: {
+            accept: "application/json",
+            "x-cg-pro-api-key": process.env.COINGECKO_API_KEY
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch token price: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    // Check if the contract address exists in the response
+    if (!data[contractAddress]) {
+        throw new Error(`No price data found for contract address: ${contractAddress}`);
+    }
+    // Check if the requested currency exists in the response
+    if (typeof data[contractAddress][vsCurrency] !== "number") {
+        throw new Error(`No price data found for currency: ${vsCurrency}`);
+    }
+    // Return the price with proper type checking
+    return data[contractAddress][vsCurrency];
+}
+function useTokenPrice({ contractAddress, chainId = 8453, // Default to Base
+vsCurrency = "usd", refreshInterval = 30000, queryOptions = {} }) {
+    const { data: price = 0, isLoading, error, refetch } = (0, react_query_1.useQuery)({
+        queryKey: ["tokenPrice", contractAddress, chainId, vsCurrency],
+        queryFn: () => fetchTokenPrice(contractAddress, chainId, vsCurrency),
+        refetchInterval: refreshInterval,
+        staleTime: refreshInterval / 2, // Consider data stale after half the refresh interval
+        retry: 3,
+        retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, 30000),
+        ...queryOptions
+    });
+    return {
+        price,
+        isLoading,
+        error,
+        refetch
+    };
+}
+exports.default = useTokenPrice;

package/dist/cjs/global-account/react/hooks/useTokenPriceWithFallback.d.ts

@@ -0,0 +1,15 @@
+import { type ChainId } from "../../../shared/constants/chains/chainPlatformMap";
+interface UseExchangeRateWithFallbackProps {
+    contractAddress: string;
+    symbol?: string;
+    chainId?: ChainId;
+    vsCurrency?: string;
+    refreshInterval?: number;
+}
+export declare function useExchangeRateWithFallback({ contractAddress, symbol, chainId, // Default to Base
+vsCurrency, refreshInterval }: UseExchangeRateWithFallbackProps): {
+    price: number;
+    isLoading: boolean;
+    error: false | Error | null;
+};
+export {};

package/dist/cjs/global-account/react/hooks/useTokenPriceWithFallback.js

@@ -0,0 +1,34 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExchangeRateWithFallback = useExchangeRateWithFallback;
+const useExchangeRate_1 = require("./useExchangeRate");
+const useTokenPrice_1 = require("./useTokenPrice");
+function useExchangeRateWithFallback({ contractAddress, symbol, chainId = 8453, // Default to Base
+vsCurrency = "usd", refreshInterval = 30000 }) {
+    // Try to get the exchange rate using the symbol if provided
+    const { rate: exchangeRate, isLoading: isExchangeRateLoading, error: exchangeRateError } = (0, useExchangeRate_1.useExchangeRate)({
+        baseCurrency: symbol || "",
+        quoteCurrency: vsCurrency,
+        refreshInterval
+    });
+    // Only call useTokenPrice if exchange rate is not available
+    const { price: tokenPrice, isLoading: isTokenPriceLoading, error: tokenPriceError } = (0, useTokenPrice_1.useTokenPrice)({
+        contractAddress,
+        chainId,
+        vsCurrency,
+        refreshInterval,
+        queryOptions: {
+            enabled: !isExchangeRateLoading && !exchangeRate && !exchangeRateError
+        }
+    });
+    // Determine which price to use
+    const price = exchangeRate || tokenPrice;
+    const isLoading = isExchangeRateLoading || (isTokenPriceLoading && !exchangeRate);
+    const error = exchangeRateError || (!exchangeRate && tokenPriceError);
+    return {
+        price,
+        isLoading,
+        error
+    };
+}

package/dist/cjs/global-account/react/hooks/useTokensFromAddress.d.ts

@@ -0,0 +1,54 @@
+interface TokenAttribute {
+    trait_type: string;
+    value: string | number;
+    display_type?: string;
+}
+interface TokenCollection {
+    name?: string;
+    description?: string;
+    image_url?: string;
+    banner_image_url?: string;
+    featured_image_url?: string;
+    external_link?: string;
+}
+interface TokenContract {
+    name?: string;
+    symbol?: string;
+    type?: "erc721" | "erc1155";
+}
+export interface Token {
+    chainId: number;
+    chain_id: number;
+    tokenAddress: string;
+    token_address: string;
+    tokenId: string;
+    token_id: string;
+    balance: string;
+    name?: string;
+    description?: string;
+    image_url?: string;
+    video_url?: string;
+    animation_url?: string;
+    background_color?: string;
+    external_url?: string;
+    status?: string;
+    owner_addresses?: string[];
+    extra_metadata?: {
+        attributes?: TokenAttribute[] | Record<string, any>;
+        properties?: Record<string, any>;
+    };
+    collection?: TokenCollection;
+    contract?: TokenContract;
+}
+export interface TokensResponse {
+    data: Token[];
+}
+interface UseTokensFromAddressProps {
+    ownerAddress?: string;
+    chain?: number | number[];
+    limit?: number;
+    page?: number;
+    metadata?: boolean;
+}
+export declare function useTokensFromAddress({ ownerAddress, chain, limit, page, metadata }: UseTokensFromAddressProps): import("@tanstack/react-query").UseQueryResult<TokensResponse, Error>;
+export {};

package/dist/cjs/global-account/react/hooks/useTokensFromAddress.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTokensFromAddress = useTokensFromAddress;
+const constants_1 = require("../../../shared/constants");
+const react_query_1 = require("@tanstack/react-query");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)("@@b3:useTokensFromAddress");
+function useTokensFromAddress({ ownerAddress, chain, limit = 50, page = 0, metadata = true }) {
+    return (0, react_query_1.useQuery)({
+        queryKey: ["useTokensFromAddress", ownerAddress, chain, limit, page, metadata],
+        queryFn: async () => {
+            if (!ownerAddress) {
+                return { data: [] };
+            }
+            const params = new URLSearchParams();
+            // Handle chain parameter(s)
+            if (chain) {
+                if (Array.isArray(chain)) {
+                    // Add multiple chain parameters
+                    chain.forEach(chainId => {
+                        params.append("chain", chainId.toString());
+                    });
+                }
+                else {
+                    // Add single chain parameter
+                    params.append("chain", chain.toString());
+                }
+            }
+            if (limit)
+                params.append("limit", limit.toString());
+            if (page)
+                params.append("page", page.toString());
+            if (metadata)
+                params.append("metadata", metadata.toString());
+            params.append("clientId", constants_1.THIRDWEB_CLIENT_ID);
+            const queryString = params.toString();
+            const url = `https://insight.thirdweb.com/v1/tokens/erc1155/${ownerAddress}${queryString ? `?${queryString}` : ""}`;
+            debug("Fetching tokens:", url);
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch tokens: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data;
+        },
+        enabled: Boolean(ownerAddress)
+    });
+}

package/dist/cjs/global-account/react/hooks/useURLParams.d.ts

@@ -0,0 +1,8 @@
+interface UpdateURLParamsOptions {
+    preserveParams?: string[];
+}
+export declare function useURLParams(): {
+    searchParams: URLSearchParams;
+    updateURLParams: (updates: Record<string, string | null>, options?: UpdateURLParamsOptions) => void;
+};
+export {};