import { type ChainData, type CosmosChain, type Token } from "@0xsquid/squid-types";
import { CantonConnector } from "../../core/types/canton";
import type { TokenWithBalance } from "../../core/types/tokens";
export declare const getTokensSupportingMultiCall: (tokens: Token[], userAddress: string, chains: ChainData[]) => Promise<TokenWithBalance[]>;
export declare const getAllEvmTokensBalance: (evmTokens: Token[], userAddress: string, chains: ChainData[]) => Promise<TokenWithBalance[]>;
export declare const getWorkingCosmosRpcUrl: (chainData: ChainData) => Promise<string>;
/**
 * Get the balance of a single token for a given address
 * @param chainRpc - rpc url
 * @param address - user address
 * @param tokenAddress - token address
 * @returns balance as string
 */
export declare const getCosmosTokenBalance: (chain: ChainData, address: string, tokenAddress: string) => Promise<string>;
/**
 * Fetches all Cosmos balances for a given address and RPC.
 *
 * @param {string} params.rpc - RPC URL to fetch balances from.
 * @param {string} params.address - user address to fetch balances for.
 * @param {Token[]} params.tokens - array of Cosmos tokens.
 * @returns {Promise<TokenWithBalance[]>} promise that resolves to an array of tokens with their balances.
 */
export declare const getAllCosmosBalancesForChain: ({ rest, address, tokens, }: {
    rest: string;
    tokens: Token[];
    address: string;
}) => Promise<TokenWithBalance[]>;
/**
 * Fetches all Cosmos balances for a given address and RPC.
 *
 * @param {object} params.addresses user addresses per cosmos network
 * @param {Token[]} params.cosmosTokens
 * @param {CosmosChain[]} params.cosmosChains
 * @returns {Promise<TokenWithBalance[]>} All tokens with their balances.
 */
export declare const getAllCosmosBalances: ({ addresses, cosmosTokens, cosmosChains, }: {
    addresses: {
        chainId: string;
        address: string;
    }[];
    cosmosTokens: Token[];
    cosmosChains: CosmosChain[];
}) => Promise<TokenWithBalance[]>;
export declare const getSolanaNativeBalance: (userAddress: string) => Promise<bigint>;
export declare const getSolanaTokenBalance: (userAddress: string, tokenAddress: string) => Promise<bigint>;
export declare const getSolanaTokensBalance: (userAddress: string, tokenAddresses: string[]) => Promise<{
    [address: string]: bigint;
}>;
export declare const getAllSolanaTokensBalance: (solanaTokens: Token[], userAddress: string) => Promise<TokenWithBalance[]>;
export declare function getBitcoinNativeBalance(address: string): Promise<string>;
export declare const getAllBitcoinTokensBalance: (userAddress: string, bitcoinTokens: Token[]) => Promise<TokenWithBalance[]>;
/**
 * Returns the balance of a single Sui coin for a given address
 */
export declare const getSuiTokenBalance: (userAddress: string, tokenAddress: string, rpcUrl: string) => Promise<bigint>;
export declare const getAllSuiTokensBalance: (userAddress: string, suiTokens: Token[], suiChains: ChainData[]) => Promise<TokenWithBalance[]>;
export declare const getXrplTokenBalance: (userAddress: string, token: Pick<Token, "decimals" | "address">, chain: ChainData) => Promise<bigint>;
export declare const getAllXrplTokensBalance: (userAddress: string, xrplTokens: Token[], xrplChains: ChainData[]) => Promise<TokenWithBalance[]>;
export declare const getStellarTokenBalance: (userAddress: string, token: Token, chain: ChainData) => Promise<bigint>;
export declare const getAllStellarTokensBalance: (userAddress: string, stellarTokens: Token[], stellarChains: ChainData[]) => Promise<TokenWithBalance[]>;
/**
 * Canton balances are private: they can only be read with a wallet-authorized
 * `ledgerApi` session (the connected wallet supplies a JWT that can read as the
 * party). So balance is fetchable only when a Canton wallet is connected, and
 * only for that wallet's party — there's no address-only read.
 */
export declare const getCantonTokenBalance: (userAddress: string, token: Token, cantonConnector: CantonConnector) => Promise<string>;
/**
 * Fetch balances for all Canton tokens in one ACS query. Canton balances are
 * private, so this requires a connected wallet's authorized `ledgerApi`.
 */
export declare function getAllCantonTokensBalance({ connector, partyId, tokens, }: {
    connector: CantonConnector;
    partyId: string;
    tokens: Token[];
}): Promise<TokenWithBalance[]>;
/**
 * Returns a promise that resolves when the given promise resolves or after the given timeout
 * @param ms - timeout in milliseconds
 * @param promise - the promise to wait for
 */
export declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T | null>;