graz 0.0.44 → 0.0.45-alpha.1

package/dist/index.d.ts

@@ -1,13 +1,12 @@
+import { ChainInfo, AppCurrency, Bech32Config, Keplr, Key, OfflineAminoSigner, OfflineDirectSigner as OfflineDirectSigner$1 } from '@keplr-wallet/types';
+import { SignClientTypes } from '@walletconnect/types';
+import { Web3ModalConfig } from '@web3modal/standalone';
 import * as _cosmjs_cosmwasm_stargate from '@cosmjs/cosmwasm-stargate';
-import { SigningCosmWasmClientOptions, CosmWasmClient, SigningCosmWasmClient, InstantiateOptions, InstantiateResult, ExecuteResult } from '@cosmjs/cosmwasm-stargate';
-import * as _keplr_wallet_types from '@keplr-wallet/types';
-import { ChainInfo, AppCurrency, Keplr, Key } from '@keplr-wallet/types';
-import * as _cosmjs_proto_signing from '@cosmjs/proto-signing';
-import { Coin, OfflineSigner, OfflineDirectSigner } from '@cosmjs/proto-signing';
-import { QueryClient, StargateClient, SigningStargateClient, SigningStargateClientOptions, StdFee, DeliverTxResponse, StakingExtension } from '@cosmjs/stargate';
+import { CosmWasmClient, SigningCosmWasmClientOptions, SigningCosmWasmClient, InstantiateOptions } from '@cosmjs/cosmwasm-stargate';
+import { OfflineSigner, OfflineDirectSigner, Coin } from '@cosmjs/proto-signing';
+import * as _cosmjs_stargate from '@cosmjs/stargate';
+import { StargateClient, StargateClientOptions, SigningStargateClient, StdFee, DeliverTxResponse, QueryClient, StakingExtension, Coin as Coin$1 } from '@cosmjs/stargate';
 import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
-import { ISignClient, SignClientTypes } from '@walletconnect/types';
-import { Web3ModalConfig } from '@web3modal/standalone';
 import { Height } from 'cosmjs-types/ibc/core/client/v1/client';
 import { OfflineSigner as OfflineSigner$1 } from '@cosmjs/launchpad';
 import * as _tanstack_react_query from '@tanstack/react-query';
@@ -34,6 +33,7 @@ interface GrazChain {
         price: string;
         denom: string;
     };
+    bech32Config: Bech32Config;
 }
 /**
  * Helper function to define chain information records (key values).
@@ -158,6 +158,21 @@ declare const testnetChains: {
  */
 declare const testnetChainsArray: ChainInfo[];
 
+type Clients = "cosmWasm" | "stargate" | "tendermint";
+type ConnectClientArgs<T extends Clients> = Pick<GrazChain, "rpc" | "rpcHeaders"> & {
+    client: T;
+};
+type ConnectClient<T> = T extends "cosmWasm" ? CosmWasmClient : T extends "stargate" ? StargateClient : T extends "tendermint" ? Tendermint34Client : never;
+declare const connectClient: <T extends Clients>({ rpc, rpcHeaders, client }: ConnectClientArgs<T>) => Promise<ConnectClient<T>>;
+type SigningClients = "cosmWasm" | "stargate";
+type ConnectSigningClientArgs<T extends SigningClients> = Pick<GrazChain, "rpc" | "rpcHeaders"> & {
+    client: T;
+    offlineSignerAuto: OfflineSigner | OfflineDirectSigner;
+    options?: T extends "cosmWasm" ? SigningCosmWasmClientOptions : T extends "stargate" ? StargateClientOptions : never;
+};
+type ConnectSigningClient<T> = T extends "cosmWasm" ? SigningCosmWasmClient : T extends "stargate" ? SigningStargateClient : never;
+declare const connectSigningClient: <T extends SigningClients>(args: ConnectSigningClientArgs<T>) => Promise<ConnectSigningClient<T>>;
+
 declare enum WalletType {
     KEPLR = "keplr",
     LEAP = "leap",
@@ -174,108 +189,68 @@ type Wallet = Pick<Keplr, "enable" | "getKey" | "getOfflineSigner" | "getOffline
     init?: () => Promise<unknown>;
 };
 
+interface WalletConnectStore {
+    options: SignClientTypes.Options | null;
+    web3Modal?: Pick<Web3ModalConfig, "themeVariables" | "themeMode" | "privacyPolicyUrl" | "termsOfServiceUrl"> | null;
+}
+interface GrazInternalStore {
+    chains: GrazChain[] | null;
+    recentChains: string[] | null;
+    defaultClient: Clients;
+    defaultSigningClient: SigningClients;
+    walletType: WalletType;
+    walletConnect: WalletConnectStore | null;
+    _notFoundFn: () => void;
+    _reconnect: boolean;
+    _reconnectConnector: WalletType | null;
+    _onReconnectFailed: () => void;
+}
+interface GrazAccountSession {
+    account: Key | null;
+    chainId: string;
+    status: "connected" | "connecting" | "reconnecting" | "disconnected";
+}
+
 type ConnectArgs = Maybe<{
-    chain?: GrazChain;
-    signerOpts?: SigningCosmWasmClientOptions;
+    chainId: string[];
     walletType?: WalletType;
     autoReconnect?: boolean;
 }>;
 interface ConnectResult {
-    account: Key;
     walletType: WalletType;
-    chain: GrazChain;
+    sessions: GrazAccountSession[];
 }
 declare const connect: (args?: ConnectArgs) => Promise<ConnectResult>;
-declare const disconnect: (clearRecentChain?: boolean) => Promise<void>;
+interface OfflineSigners {
+    offlineSigner: OfflineAminoSigner & OfflineDirectSigner$1;
+    offlineSignerAmino: OfflineAminoSigner;
+    offlineSignerAuto: OfflineAminoSigner | OfflineDirectSigner$1;
+}
+declare const getOfflineSigners: (args?: {
+    walletType?: WalletType;
+    chainId: string;
+}) => Promise<OfflineSigners>;
+declare const disconnect: (args?: {
+    chainId?: string[];
+}) => Promise<void>;
 type ReconnectArgs = Maybe<{
     onError?: (error: unknown) => void;
 }>;
 declare const reconnect: (args?: ReconnectArgs) => Promise<ConnectResult | undefined>;
 
-type ExtensionSetup<P extends object = object> = (queryClient: QueryClient) => P;
-
-interface CreateQueryClient {
-    (): QueryClient;
-    <A extends object>(setupA: ExtensionSetup<A>): QueryClient & A;
-    <A extends object, B extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>): QueryClient & A & B;
-    <A extends object, B extends object, C extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>): QueryClient & A & B & C;
-    <A extends object, B extends object, C extends object, D extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>): QueryClient & A & B & C & D;
-    <A extends object, B extends object, C extends object, D extends object, E extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>): QueryClient & A & B & C & D & E;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>): QueryClient & A & B & C & D & E & F;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>): QueryClient & A & B & C & D & E & F & G;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object, H extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>, setupH: ExtensionSetup<H>): QueryClient & A & B & C & D & E & F & G & H;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object, H extends object, I extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>, setupH: ExtensionSetup<H>, setupI: ExtensionSetup<I>): QueryClient & A & B & C & D & E & F & G & H & I;
-}
-/**
- * Note: `createQueryClient` creates \@cosmjs/stargate's {@link QueryClient},
- * NOT to be confused with \@tanstack/react-query query client
- */
-declare const createQueryClient: CreateQueryClient;
-
 declare const clearRecentChain: () => void;
-declare const getActiveChainCurrency: (denom: string) => AppCurrency | undefined;
-declare const getRecentChain: () => GrazChain | null;
+declare const getRecentChains: () => string[] | null;
 declare const suggestChain: (chainInfo: ChainInfo) => Promise<ChainInfo>;
 interface SuggestChainAndConnectArgs {
     chainInfo: ChainInfo;
-    signerOpts?: SigningCosmWasmClientOptions;
-    walletType?: WalletType;
-    gas?: {
-        price: string;
-        denom: string;
-    };
-    rpcHeaders?: Dictionary;
-    path?: string;
     autoReconnect?: boolean;
+    walletType?: WalletType;
 }
-declare const suggestChainAndConnect: ({ chainInfo, rpcHeaders, gas, path, ...rest }: SuggestChainAndConnectArgs) => Promise<ConnectResult>;
-
-interface WalletConnectStore {
-    options: SignClientTypes.Options | null;
-    web3Modal?: Pick<Web3ModalConfig, "themeVariables" | "themeMode" | "privacyPolicyUrl" | "termsOfServiceUrl"> | null;
-}
-interface GrazInternalStore {
-    defaultChain: GrazChain | null;
-    defaultSigningClient: "cosmWasm" | "stargate";
-    recentChain: GrazChain | null;
-    walletType: WalletType;
-    walletConnect: WalletConnectStore | null;
-    _notFoundFn: () => void;
-    _reconnect: boolean;
-    _reconnectConnector: WalletType | null;
-    _onReconnectFailed: () => void;
-}
-interface GrazSessionStore {
-    account: Key | null;
-    activeChain: GrazChain | null;
-    balances: Coin[] | null;
-    clients: {
-        cosmWasm: CosmWasmClient;
-        stargate: StargateClient;
-        tendermint: Tendermint34Client;
-    } | null;
-    offlineSigner: (OfflineSigner & OfflineDirectSigner) | null;
-    offlineSignerAmino: OfflineSigner | null;
-    offlineSignerAuto: (OfflineSigner | OfflineDirectSigner) | null;
-    signingClients: {
-        cosmWasm: SigningCosmWasmClient;
-        stargate: SigningStargateClient;
-    } | null;
-    status: "connected" | "connecting" | "reconnecting" | "disconnected";
-    wcSignClient?: ISignClient | null;
-}
-
-type CreateClientArgs = Pick<GrazChain, "rpc" | "rpcHeaders">;
-declare const createClients: ({ rpc, rpcHeaders }: CreateClientArgs) => Promise<GrazSessionStore["clients"]>;
-type CreateSigningClientArgs = CreateClientArgs & {
-    offlineSignerAuto: OfflineSigner | OfflineDirectSigner;
-    cosmWasmSignerOptions?: SigningCosmWasmClientOptions;
-    stargateSignerOptions?: SigningStargateClientOptions;
-};
-declare const createSigningClients: (args: CreateSigningClientArgs) => Promise<GrazSessionStore["signingClients"]>;
+declare const suggestChainAndConnect: (args: SuggestChainAndConnectArgs) => Promise<ConnectResult>;
 
 interface ConfigureGrazArgs {
-    defaultChain?: GrazChain;
+    chains?: GrazChain[];
+    defaultClient?: GrazInternalStore["defaultClient"];
     defaultSigningClient?: GrazInternalStore["defaultSigningClient"];
     defaultWallet?: WalletType;
     onNotFound?: () => void;
@@ -286,20 +261,29 @@ interface ConfigureGrazArgs {
      */
     autoReconnect?: boolean;
 }
-declare const configureGraz: (args?: ConfigureGrazArgs) => ConfigureGrazArgs;
+declare const configureGraz: (args: ConfigureGrazArgs) => ConfigureGrazArgs;
 
-declare const getBalances: (bech32Address: string) => Promise<Coin[]>;
-declare const getBalanceStaked: (bech32Address: string) => Promise<Coin | null>;
-interface SendTokensArgs {
-    senderAddress?: string;
+declare const getBalances: <T extends "cosmWasm" | "stargate">({ bech32Address, client, currencies, }: {
+    currencies: AppCurrency[];
+    bech32Address: string;
+    client: ConnectClient<T>;
+}) => Promise<Coin[]>;
+declare const getBalanceStaked: ({ bech32Address, client, }: {
+    bech32Address: string;
+    client: ConnectClient<"stargate">;
+}) => Promise<Coin | null>;
+interface SendTokensArgs<T> {
+    signingClient: ConnectSigningClient<T>;
+    senderAddress: string;
     recipientAddress: string;
     amount: Coin[];
     fee: number | StdFee | "auto";
     memo?: string;
 }
-declare const sendTokens: ({ senderAddress, recipientAddress, amount, fee, memo, }: SendTokensArgs) => Promise<DeliverTxResponse>;
+declare const sendTokens: <T extends SigningClients>({ senderAddress, recipientAddress, amount, fee, memo, signingClient, }: SendTokensArgs<T>) => Promise<DeliverTxResponse>;
 interface SendIbcTokensArgs {
-    senderAddress?: string;
+    signingClient: ConnectSigningClient<"stargate">;
+    senderAddress: string;
     recipientAddress: string;
     transferAmount: Coin;
     sourcePort: string;
@@ -309,8 +293,9 @@ interface SendIbcTokensArgs {
     fee: number | StdFee | "auto";
     memo?: string;
 }
-declare const sendIbcTokens: ({ senderAddress, recipientAddress, transferAmount, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, fee, memo, }: SendIbcTokensArgs) => Promise<DeliverTxResponse>;
+declare const sendIbcTokens: ({ signingClient, senderAddress, recipientAddress, transferAmount, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, fee, memo, }: SendIbcTokensArgs) => Promise<DeliverTxResponse>;
 interface InstantiateContractArgs<Message extends Record<string, unknown>> {
+    signingClient: ConnectSigningClient<"cosmWasm">;
     msg: Message;
     label: string;
     fee: StdFee | "auto" | number;
@@ -321,8 +306,9 @@ interface InstantiateContractArgs<Message extends Record<string, unknown>> {
 type InstantiateContractMutationArgs<Message extends Record<string, unknown>> = Omit<InstantiateContractArgs<Message>, "codeId" | "senderAddress" | "fee"> & {
     fee?: StdFee | "auto" | number;
 };
-declare const instantiateContract: <Message extends Record<string, unknown>>({ senderAddress, msg, fee, options, label, codeId, }: InstantiateContractArgs<Message>) => Promise<_cosmjs_cosmwasm_stargate.InstantiateResult>;
+declare const instantiateContract: <Message extends Record<string, unknown>>({ signingClient, senderAddress, msg, fee, options, label, codeId, }: InstantiateContractArgs<Message>) => Promise<_cosmjs_cosmwasm_stargate.InstantiateResult>;
 interface ExecuteContractArgs<Message extends Record<string, unknown>> {
+    signingClient: ConnectSigningClient<"cosmWasm">;
     msg: Message;
     fee: StdFee | "auto" | number;
     senderAddress: string;
@@ -335,9 +321,17 @@ type ExecuteContractMutationArgs<Message extends Record<string, unknown>> = Omit
     funds?: Coin[];
     memo?: string;
 };
-declare const executeContract: <Message extends Record<string, unknown>>({ senderAddress, msg, fee, contractAddress, funds, memo, }: ExecuteContractArgs<Message>) => Promise<_cosmjs_cosmwasm_stargate.ExecuteResult>;
-declare const getQuerySmart: <TData>(address: string, queryMsg: Record<string, unknown>) => Promise<TData>;
-declare const getQueryRaw: (address: string, keyStr: string) => Promise<Uint8Array | null>;
+declare const executeContract: <Message extends Record<string, unknown>>({ signingClient, senderAddress, msg, fee, contractAddress, funds, memo, }: ExecuteContractArgs<Message>) => Promise<_cosmjs_cosmwasm_stargate.ExecuteResult>;
+declare const getQuerySmart: <TData>({ client, address, queryMsg, }: {
+    client: ConnectClient<"cosmWasm">;
+    address: string;
+    queryMsg: Record<string, unknown>;
+}) => Promise<TData>;
+declare const getQueryRaw: ({ client, address, keyStr, }: {
+    client: ConnectClient<"cosmWasm">;
+    address: string;
+    keyStr: string;
+}) => Promise<Uint8Array | null>;
 
 /**
  * Function to check whether given {@link WalletType} or default configured wallet exists.
@@ -458,14 +452,31 @@ interface GrazAdapter extends Connector {
     keystoreEvent: string;
 }
 
+interface ChainIdArgs {
+    /**
+     * if provided, it will only return the data of the given chainId
+     */
+    chainId?: string | undefined;
+}
+type HookResultDataWithChainId<T, U extends ChainIdArgs> = U["chainId"] extends string ? T : Record<string, T>;
+
 interface MutationEventArgs<TInitial = unknown, TSuccess = TInitial> {
     onError?: (error: unknown, data: TInitial) => unknown;
     onLoading?: (data: TInitial) => unknown;
     onSuccess?: (data: TSuccess) => unknown;
 }
 
+interface UseAccount {
+    data?: GrazAccountSession;
+    isConnected: boolean;
+    isConnecting: boolean;
+    isDisconnected: boolean;
+    isReconnecting: boolean;
+    isLoading: boolean;
+    status?: GrazAccountSession["status"];
+}
 interface UseAccountArgs {
-    onConnect?: (args: ConnectResult & {
+    onConnect?: (args: GrazAccountSession & {
         isReconnect: boolean;
     }) => void;
     onDisconnect?: () => void;
@@ -488,51 +499,7 @@ interface UseAccountArgs {
  * });
  * ```
  */
-declare const useAccount: ({ onConnect, onDisconnect }?: UseAccountArgs) => {
-    data: _keplr_wallet_types.Key | null;
-    isConnected: boolean;
-    isConnecting: boolean;
-    isDisconnected: boolean;
-    isReconnecting: boolean;
-    isLoading: boolean;
-    reconnect: (args?: ReconnectArgs) => Promise<ConnectResult | undefined>;
-    status: "connected" | "connecting" | "reconnecting" | "disconnected";
-};
-/**
- * graz query hook to retrieve list of balances from current account or given address.
- *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
- *
- * @example
- * ```ts
- * import { useBalances } from "graz";
- *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalances();
- *
- * // with custom bech32 address
- * useBalances("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
- * ```
- */
-declare const useBalances: (bech32Address?: string) => UseQueryResult<Coin[]>;
-/**
- * graz query hook to retrieve specific asset balance from current account or given address.
- *
- * @param denom - Asset denom to search
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
- *
- * @example
- * ```ts
- * import { useBalance } from "graz";
- *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalance("atom");
- *
- * // with custom bech32 address
- * useBalance("atom", "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
- * ```
- */
-declare const useBalance: (denom: string, bech32Address?: string) => UseQueryResult<Coin | undefined>;
+declare const useAccount: <T extends ChainIdArgs>(args?: (UseAccountArgs & T) | undefined) => HookResultDataWithChainId<UseAccount, T> | undefined;
 type UseConnectChainArgs = MutationEventArgs<ConnectArgs, ConnectResult>;
 /**
  * graz mutation hook to execute wallet connection with optional arguments to
@@ -602,8 +569,12 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
  * @see {@link disconnect}
  */
 declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventArgs) => {
-    disconnect: (forget?: boolean) => void;
-    disconnectAsync: (forget?: boolean) => Promise<void>;
+    disconnect: (args?: {
+        chainid?: string[];
+    }) => void;
+    disconnectAsync: (args?: {
+        chainid?: string[];
+    }) => Promise<void>;
     error: unknown;
     isLoading: boolean;
     isSuccess: boolean;
@@ -620,62 +591,8 @@ declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventA
  * const { signer, signerAmino, signerAuto } = useOfflineSigners();
  * ```
  */
-declare const useOfflineSigners: () => {
-    signer: (_cosmjs_proto_signing.OfflineSigner & _cosmjs_proto_signing.OfflineDirectSigner) | null;
-    signerAmino: _cosmjs_proto_signing.OfflineSigner | null;
-    signerAuto: _cosmjs_proto_signing.OfflineSigner | null;
-};
-/**
- * graz hook to retrieve offline signer objects (default, amino enabled, and auto).
- *
- * @deprecated prefer using {@link useOfflineSigners}
- * @see {@link useOfflineSigners}
- */
-declare const useSigners: () => {
-    signer: (_cosmjs_proto_signing.OfflineSigner & _cosmjs_proto_signing.OfflineDirectSigner) | null;
-    signerAmino: _cosmjs_proto_signing.OfflineSigner | null;
-    signerAuto: _cosmjs_proto_signing.OfflineSigner | null;
-};
-/**
- * graz query hook to retrieve list of staked balances from current account or given address.
- *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
- *
- * @example
- * ```ts
- * import { useBalanceStaked } from "graz";
- *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalanceStaked();
- *
- * // with custom bech32 address
- * useBalanceStaked("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
- * ```
- */
-declare const useBalanceStaked: (bech32Address?: string) => UseQueryResult<Coin | null>;
+declare const useOfflineSigners: <T extends ChainIdArgs>(args?: T | undefined) => UseQueryResult<HookResultDataWithChainId<OfflineSigners, T> | undefined>;
 
-/**
- * graz hook to retrieve connected account's active chain
- *
- * @example
- * ```ts
- * import { useActiveChain } from "graz";
- * const { rpc, rest, chainId, currencies } = useActiveChain();
- * ```
- */
-declare const useActiveChain: () => GrazChain | null;
-/**
- * graz hook to retrieve specific connected account's currency
- *
- * @param denom - Currency denom to search
- *
- * @example
- * ```ts
- * import { useActiveChainCurrency } from "graz";
- * const { data: currency, ... } = useActiveChainCurrency("juno");
- * ```
- */
-declare const useActiveChainCurrency: (denom: string) => UseQueryResult<AppCurrency | undefined>;
 /**
  * graz hook to retrieve active chain validators with given query client and optional bond status
  *
@@ -709,7 +626,7 @@ declare const useActiveChainValidators: <T extends QueryClient & StakingExtensio
  * @see {@link useActiveChain}
  */
 declare const useRecentChain: () => {
-    data: GrazChain | null;
+    data: string[] | null;
     clear: () => void;
 };
 type UseSuggestChainArgs = MutationEventArgs<ChainInfo>;
@@ -792,7 +709,15 @@ declare const useSuggestChainAndConnect: ({ onError, onLoading, onSuccess }?: Us
  * useClient({ rpc: "https://rpc.cosmoshub.strange.love", });
  * ```
  */
-declare const useClients: (args?: CreateClientArgs) => UseQueryResult<GrazSessionStore["clients"]>;
+declare const useConnectClient: <T extends Clients, U extends ChainIdArgs>(args?: ({
+    client?: T | undefined;
+    /**
+     *
+     *  if true, it will only return the client of the given connected chains
+     */
+    onlyConnectedChains?: boolean | undefined;
+    enabled?: boolean | undefined;
+} & U) | undefined) => UseQueryResult<HookResultDataWithChainId<ConnectClient<T>, U> | undefined>;
 /**
  * graz query hook to retrieve a SigningCosmWasmClient. If there's no given args it will be using the current connected signer
  *
@@ -811,180 +736,63 @@ declare const useClients: (args?: CreateClientArgs) => UseQueryResult<GrazSessio
  * });
  * ```
  */
-declare const useSigningClients: (args?: CreateSigningClientArgs) => UseQueryResult<GrazSessionStore["signingClients"]>;
+declare const useConnectSigningClient: <T extends SigningClients, U extends ChainIdArgs>(args?: ({
+    client?: T | undefined;
+    options?: (U["chainId"] extends string ? (T extends "cosmWasm" ? _cosmjs_cosmwasm_stargate.SigningCosmWasmClientOptions : T extends "stargate" ? _cosmjs_stargate.StargateClientOptions : never) | undefined : Record<string, (T extends "cosmWasm" ? _cosmjs_cosmwasm_stargate.SigningCosmWasmClientOptions : T extends "stargate" ? _cosmjs_stargate.StargateClientOptions : never) | undefined>) | undefined;
+} & U) | undefined) => UseQueryResult<HookResultDataWithChainId<ConnectSigningClient<T>, U> | undefined>;
 
-interface UseQueryClient {
-    (): UseQueryResult<QueryClient>;
-    <A extends object>(setupA: ExtensionSetup<A>): UseQueryResult<QueryClient & A>;
-    <A extends object, B extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>): UseQueryResult<QueryClient & A & B>;
-    <A extends object, B extends object, C extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>): UseQueryResult<QueryClient & A & B & C>;
-    <A extends object, B extends object, C extends object, D extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>): UseQueryResult<QueryClient & A & B & C & D>;
-    <A extends object, B extends object, C extends object, D extends object, E extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>): UseQueryResult<QueryClient & A & B & C & D & E>;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>): UseQueryResult<QueryClient & A & B & C & D & E & F>;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>): UseQueryResult<QueryClient & A & B & C & D & E & F & G>;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object, H extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>, setupH: ExtensionSetup<H>): UseQueryResult<QueryClient & A & B & C & D & E & F & G & H>;
-    <A extends object, B extends object, C extends object, D extends object, E extends object, F extends object, G extends object, H extends object, I extends object>(setupA: ExtensionSetup<A>, setupB: ExtensionSetup<B>, setupC: ExtensionSetup<C>, setupD: ExtensionSetup<D>, setupE: ExtensionSetup<E>, setupF: ExtensionSetup<F>, setupG: ExtensionSetup<G>, setupH: ExtensionSetup<H>, setupI: ExtensionSetup<I>): UseQueryResult<QueryClient & A & B & C & D & E & F & G & H & I>;
-}
 /**
- * graz query hook to create and use {@link QueryClient} similar when using {@link QueryClient.withExtensions}.
- *
- * Note: `useQueryClient` returns \@cosmjs/stargate's {@link QueryClient},
- * NOT to be confused with \@tanstack/react-query useQueryClient.
- *
- * @example
- * ```ts
- * // example without extensions
- * import { useQueryClient } from "graz";
- *
- * const queryClient = useQueryClient();
- *
- * // example with extensions
- * import { useQueryClient } from "graz";
- * import { setupAuthExtension, setupIbcExtension } from "@cosmjs/stargate";
- *
- * const queryClientWithExtensions = useQueryClient(setupAuthExtension, setupIbcExtension);
- * ```
+ * graz query hook to retrieve list of balances from current account or given address.
  *
- * @see {@link createQueryClient}
- */
-declare const useQueryClient: UseQueryClient;
-
-/**
- * graz mutation hook to send tokens. Note: if `senderAddress` undefined, it will use current connected account address.
+ * @param bech32Address - Optional bech32 account address, defaults to connected account address
  *
  * @example
  * ```ts
- * import { useSendTokens } from "graz";
+ * import { useBalances } from "graz";
  *
  * // basic example
- * const { sendTokens } = useSendTokens();
+ * const { data, isFetching, refetch, ... } = useBalances();
  *
- * sendTokens({
- *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430";
- *    amount: [coin];
- *    ...
- * })
+ * // with custom bech32 address
+ * useBalances("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
  * ```
- *
- * @see {@link sendTokens}
  */
-declare const useSendTokens: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SendTokensArgs, DeliverTxResponse>) => {
-    error: unknown;
-    isLoading: boolean;
-    isSuccess: boolean;
-    sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, unknown, SendTokensArgs, unknown>;
-    sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, unknown, SendTokensArgs, unknown>;
-    status: "error" | "idle" | "loading" | "success";
-};
+declare const useBalances: <T extends "cosmWasm" | "stargate", U extends ChainIdArgs>(args: {
+    bech32Address?: string | undefined;
+    client?: T | undefined;
+} & U) => UseQueryResult<HookResultDataWithChainId<Coin$1[], U>>;
 /**
- * graz mutation hook to send IBC tokens. Note: if `senderAddress` undefined, it will use current connected account address.
+ * graz query hook to retrieve list of staked balances from current account or given address.
  *
+ * @param bech32Address - Optional bech32 account address, defaults to connected account address
  *
  * @example
  * ```ts
- * import { useSendIbcTokens } from "graz";
+ * import { useBalanceStaked } from "graz";
  *
  * // basic example
- * const { sendIbcTokens } = useSendIbcTokens();
- *
- * sendIbcTokens({
- *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430",
- *    transferAmount: coin,
- *    ...
- * })
- * ```
- */
-declare const useSendIbcTokens: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SendIbcTokensArgs, DeliverTxResponse>) => {
-    error: unknown;
-    isLoading: boolean;
-    isSuccess: boolean;
-    sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, unknown, SendIbcTokensArgs, unknown>;
-    sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, unknown, SendIbcTokensArgs, unknown>;
-    status: "error" | "idle" | "loading" | "success";
-};
-type UseInstantiateContractArgs<Message extends Record<string, unknown>> = {
-    codeId: number;
-} & MutationEventArgs<InstantiateContractMutationArgs<Message>, InstantiateResult>;
-/**
- * graz mutation hook to instantiate a CosmWasm smart contract when supported.
- *
- * @example
- * ```ts
- * import { useInstantiateContract } from "graz"
- *
- * const { instantiateContract: instantiateMyContract } = useInstantiateContract({
- *   codeId: 4,
- *   onSuccess: ({ contractAddress }) => console.log('Address:', contractAddress)
- * })
- *
- * const instantiateMessage = { foo: 'bar' };
- * instantiateMyContract({
- *  msg: instatiateMessage,
- *  label: "test"
- * });
- * ```
- */
-declare const useInstantiateContract: <Message extends Record<string, unknown>>({ codeId, onError, onLoading, onSuccess, }: UseInstantiateContractArgs<Message>) => {
-    error: unknown;
-    isLoading: boolean;
-    isSuccess: boolean;
-    instantiateContract: _tanstack_react_query.UseMutateFunction<InstantiateResult, unknown, InstantiateContractMutationArgs<Message>, unknown>;
-    instantiateContractAsync: _tanstack_react_query.UseMutateAsyncFunction<InstantiateResult, unknown, InstantiateContractMutationArgs<Message>, unknown>;
-    status: "error" | "idle" | "loading" | "success";
-};
-type UseExecuteContractArgs<Message extends Record<string, unknown>> = {
-    contractAddress: string;
-} & MutationEventArgs<ExecuteContractMutationArgs<Message>, ExecuteResult>;
-/**
- * graz mutation hook for executing transactions against a CosmWasm smart
- * contract.
- *
- * @example
- * ```ts
- * import { useExecuteContract } from "graz"
- *
- * interface GreetMessage {
- *   name: string;
- * }
- *
- * interface GreetResponse {
- *   message: string;
- * }
+ * const { data, isFetching, refetch, ... } = useBalanceStaked();
  *
- * const contractAddress = "cosmosfoobarbaz";
- * const { executeContract } = useExecuteContract<ExecuteMessage>({ contractAddress });
- * executeContract({ msg: {
- *   foo: "bar"
- * }}, {
- *   onSuccess: (data: GreetResponse) => console.log('Got message:', data.message);
- * });
+ * // with custom bech32 address
+ * useBalanceStaked("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
  * ```
  */
-declare const useExecuteContract: <Message extends Record<string, unknown>>({ contractAddress, onError, onLoading, onSuccess, }: UseExecuteContractArgs<Message>) => {
+declare const useBalanceStaked: <T extends "stargate", U extends ChainIdArgs>(args: {
+    bech32Address?: string | undefined;
+    client?: T | undefined;
+} & U) => UseQueryResult<HookResultDataWithChainId<Coin$1 | null, U>>;
+declare const useSendTokens: <T extends SigningClients>({ signingClient, signingClientOptions, chainId, onError, onLoading, onSuccess, }: MutationEventArgs<SendTokensArgs<T>, DeliverTxResponse> & {
+    signingClient?: T | undefined;
+    signingClientOptions?: (T extends "cosmWasm" ? _cosmjs_cosmwasm_stargate.SigningCosmWasmClientOptions : T extends "stargate" ? _cosmjs_stargate.StargateClientOptions : never) | undefined;
+    chainId: string;
+}) => {
     error: unknown;
     isLoading: boolean;
     isSuccess: boolean;
-    executeContract: _tanstack_react_query.UseMutateFunction<ExecuteResult, unknown, ExecuteContractMutationArgs<Message>, unknown>;
-    executeContractAsync: _tanstack_react_query.UseMutateAsyncFunction<ExecuteResult, unknown, ExecuteContractMutationArgs<Message>, unknown>;
+    sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, unknown, SendTokensArgs<T>, unknown>;
+    sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, unknown, SendTokensArgs<T>, unknown>;
     status: "error" | "idle" | "loading" | "success";
 };
-/**
- * graz query hook for dispatching a "smart" query to a CosmWasm smart
- * contract.
- *
- * @param address - The address of the contract to query
- * @param queryMsg - The query message to send to the contract
- * @returns A query result with the result returned by the smart contract.
- */
-declare const useQuerySmart: <TData, TError>(address?: string, queryMsg?: Record<string, unknown>) => UseQueryResult<TData, TError>;
-/**
- * graz query hook for dispatching a "raw" query to a CosmWasm smart contract.
- *
- * @param address - The address of the contract to query
- * @param key - The key to lookup in the contract storage
- * @returns A query result with raw byte array stored at the key queried.
- */
-declare const useQueryRaw: <TError>(address?: string, key?: string) => UseQueryResult<Uint8Array | null, TError>;
 
 /**
  * graz hook to retrieve current active {@link WalletType}
@@ -1019,9 +827,23 @@ declare const useActiveWalletType: () => {
  */
 declare const useCheckWallet: (type?: WalletType) => UseQueryResult<boolean>;
 
+/**
+ * Graz custom hook to track `keplr_keystorechange`, `leap_keystorechange`, `accountChanged` event and reconnect state
+ *
+ * **Note: only use this hook if not using graz's provider component.**
+ */
+declare const useGrazEvents: () => null;
+/**
+ * Null component to run {@link useGrazEvents} without affecting component tree.
+ *
+ * **Note: only use this component if not using graz's provider component.**
+ */
+declare const GrazEvents: FC;
+
 type GrazProviderProps = Partial<QueryClientProviderProps> & {
-    grazOptions?: ConfigureGrazArgs;
-    debug?: boolean;
+    grazConfig: Omit<ConfigureGrazArgs, "chains"> & {
+        chains: GrazChain[];
+    };
 };
 /**
  * Provider component which extends `@tanstack/react-query`'s {@link QueryClientProvider} with built-in query client
@@ -1043,17 +865,4 @@ type GrazProviderProps = Partial<QueryClientProviderProps> & {
  */
 declare const GrazProvider: FC<GrazProviderProps>;
 
-/**
- * Graz custom hook to track `keplr_keystorechange`, `leap_keystorechange`, `accountChanged` event and reconnect state
- *
- * **Note: only use this hook if not using graz's provider component.**
- */
-declare const useGrazEvents: () => null;
-/**
- * Null component to run {@link useGrazEvents} without affecting component tree.
- *
- * **Note: only use this component if not using graz's provider component.**
- */
-declare const GrazEvents: FC;
-
-export { AccountData, ChainInfoWithPath, ConfigureGrazArgs, ConnectArgs, ConnectResult, Connector, CreateClientArgs, CreateQueryClient, CreateSigningClientArgs, Dictionary, ExecuteContractArgs, ExecuteContractMutationArgs, GetWalletConnectParams, GrazAdapter, GrazChain, GrazEvents, GrazProvider, GrazProviderProps, InstantiateContractArgs, InstantiateContractMutationArgs, Maybe, ReconnectArgs, SendIbcTokensArgs, SendTokensArgs, SuggestChainAndConnectArgs, UseAccountArgs, UseConnectChainArgs, UseExecuteContractArgs, UseInstantiateContractArgs, UseQueryClient, UseSuggestChainAndConnectArgs, UseSuggestChainArgs, WALLET_TYPES, Wallet, WalletType, checkWallet, clearRecentChain, configureGraz, connect, createClients, createQueryClient, createSigningClients, defineChain, defineChainInfo, defineChains, disconnect, executeContract, getActiveChainCurrency, getAvailableWallets, getBalanceStaked, getBalances, getCosmostation, getKeplr, getLeap, getQueryRaw, getQuerySmart, getRecentChain, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, instantiateContract, mainnetChains, mainnetChainsArray, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, testnetChains, testnetChainsArray, useAccount, useActiveChain, useActiveChainCurrency, useActiveChainValidators, useActiveWalletType, useBalance, useBalanceStaked, useBalances, useCheckWallet, useClients, useConnect, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryClient, useQueryRaw, useQuerySmart, useRecentChain, useSendIbcTokens, useSendTokens, useSigners, useSigningClients, useSuggestChain, useSuggestChainAndConnect };
+export { AccountData, ChainInfoWithPath, Clients, ConfigureGrazArgs, ConnectArgs, ConnectClient, ConnectClientArgs, ConnectResult, ConnectSigningClient, ConnectSigningClientArgs, Connector, Dictionary, ExecuteContractArgs, ExecuteContractMutationArgs, GetWalletConnectParams, GrazAdapter, GrazChain, GrazEvents, GrazProvider, GrazProviderProps, InstantiateContractArgs, InstantiateContractMutationArgs, Maybe, OfflineSigners, ReconnectArgs, SendIbcTokensArgs, SendTokensArgs, SigningClients, SuggestChainAndConnectArgs, UseAccount, UseAccountArgs, UseConnectChainArgs, UseSuggestChainAndConnectArgs, UseSuggestChainArgs, WALLET_TYPES, Wallet, WalletType, checkWallet, clearRecentChain, configureGraz, connect, connectClient, connectSigningClient, defineChain, defineChainInfo, defineChains, disconnect, executeContract, getAvailableWallets, getBalanceStaked, getBalances, getCosmostation, getKeplr, getLeap, getOfflineSigners, getQueryRaw, getQuerySmart, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, instantiateContract, mainnetChains, mainnetChainsArray, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, testnetChains, testnetChainsArray, useAccount, useActiveChainValidators, useActiveWalletType, useBalanceStaked, useBalances, useCheckWallet, useConnect, useConnectClient, useConnectSigningClient, useDisconnect, useGrazEvents, useOfflineSigners, useRecentChain, useSendTokens, useSuggestChain, useSuggestChainAndConnect };