@b3dotfun/sdk 0.0.1-alpha.1

package/dist/types/global-account/react/hooks/useBestTransactionPath.d.ts

@@ -0,0 +1,41 @@
+import { Token } from "@b3dotfun/sdk/anyspend";
+export type TransactionType = "send" | "swap" | "bridge";
+export interface SprinterOption {
+    chainId: number;
+    balance: bigint;
+    formattedBalance: string;
+}
+export interface TransactionPath {
+    type: "native" | "sprinter" | "anyspend";
+    hasNativePath: boolean;
+    hasSprinterPath: boolean;
+    availableBalance: bigint;
+    totalCrossChainBalance: number;
+    sprinterOptions?: SprinterOption[];
+}
+export interface TransactionPathResult extends TransactionPath {
+    loading: boolean;
+}
+interface UseBestTransactionPathProps {
+    amount: bigint;
+    token: Token;
+    address?: string;
+    transactionType?: TransactionType;
+}
+/**
+ * Hook to determine the optimal transaction path based on user's balances across chains
+ *
+ * @param props.amount - Amount to transact
+ * @param props.token - Token (a Token object)
+ * @param props.address - Target address (optional, defaults to self)
+ * @param props.transactionType - Type of transaction (optional, defaults to 'send')
+ *
+ * - type: The recommended path type ('native', 'sprinter', or 'anyspend')
+ * - hasNativePath: Whether direct native token transfer is possible (1st best path)
+ * - hasSprinterPath: Whether bridging via Sprinter is possible (2nd best path)
+ * - availableBalance: The user's balance of this asset
+ * - sprinterOptions: Available chains and balances for bridging
+ * @returns TransactionPathResult object containing path information and loading state
+ */
+export declare function useBestTransactionPath({ amount, token, address, transactionType: _transactionType }: UseBestTransactionPathProps): TransactionPathResult;
+export {};

package/dist/types/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/types/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/types/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/types/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/types/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/types/global-account/react/hooks/useGetAllTWSigners.d.ts

@@ -0,0 +1,30 @@
+import { Signer } from "@b3dotfun/sdk/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/types/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/types/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/types/global-account/react/hooks/useHasMounted.d.ts

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

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

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

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

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

package/dist/types/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/types/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/types/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/types/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("@b3dotfun/sdk/shared/utils/fetchBalances").AssetBalance[];
+    aggregatedTokenBalances: {
+        [key: string]: number;
+    };
+    loading: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@b3dotfun/sdk/shared/utils/fetchBalances").AssetBalance[], Error>>;
+};

package/dist/types/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/types/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/types/global-account/react/hooks/useRemoveSessionKey.d.ts

@@ -0,0 +1,16 @@
+import { ActiveSigners } from "@b3dotfun/sdk/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/types/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/types/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/types/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/types/global-account/react/hooks/useTokenBalance.d.ts

@@ -0,0 +1,12 @@
+import { Token } from "@b3dotfun/sdk/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/types/global-account/react/hooks/useTokenBalancesByChain.d.ts

@@ -0,0 +1,22 @@
+import { TokenData } from "@b3dotfun/sdk/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/types/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/types/global-account/react/hooks/useTokenFromUrl.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "@b3dotfun/sdk/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/types/global-account/react/hooks/useTokenPrice.d.ts

@@ -0,0 +1,17 @@
+import { type ChainId } from "@b3dotfun/sdk/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/types/global-account/react/hooks/useTokenPriceWithFallback.d.ts

@@ -0,0 +1,15 @@
+import { type ChainId } from "@b3dotfun/sdk/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/types/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/types/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 {};

package/dist/types/global-account/react/stores/useAuthStore.d.ts

@@ -0,0 +1,26 @@
+import type { Chain } from "thirdweb";
+interface AuthState {
+    isOpen: boolean;
+    step: "login" | "permissions";
+    provider?: string;
+    accessToken?: string;
+    chain?: Chain;
+    isAuthenticating: boolean;
+    isAuthenticated: boolean;
+    onSuccess?: (account: any) => void;
+    onError?: (error: Error) => void;
+    setB3ModalOpen: (isOpen: boolean) => void;
+    setStep: (step: "login" | "permissions") => void;
+    setIsAuthenticating: (isAuthenticating: boolean) => void;
+    setIsAuthenticated: (isAuthenticated: boolean) => void;
+    startAuth: (params: {
+        provider: string;
+        accessToken?: string;
+        chain?: Chain;
+        onSuccess?: (account: any) => void;
+        onError?: (error: Error) => void;
+    }) => void;
+    reset: () => void;
+}
+export declare const useAuthStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AuthState>>;
+export {};