graz 0.0.45-alpha.2 → 0.0.46

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-import { ChainInfo, AppCurrency, Bech32Config, Keplr, Key, OfflineAminoSigner, OfflineDirectSigner as OfflineDirectSigner$1 } from '@keplr-wallet/types';
+import * as _cosmjs_cosmwasm_stargate from '@cosmjs/cosmwasm-stargate';
+import { SigningCosmWasmClientOptions, SigningCosmWasmClient, InstantiateOptions, CosmWasmClient, InstantiateResult, ExecuteResult } from '@cosmjs/cosmwasm-stargate';
+import { OfflineDirectSigner, Coin } from '@cosmjs/proto-signing';
+import * as _keplr_wallet_types from '@keplr-wallet/types';
+import { ChainInfo, AppCurrency, Keplr, Key, OfflineAminoSigner } from '@keplr-wallet/types';
 import { SignClientTypes } from '@walletconnect/types';
 import { Web3ModalConfig } from '@web3modal/standalone';
-import * as _cosmjs_cosmwasm_stargate from '@cosmjs/cosmwasm-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 { SigningStargateClient, StdFee, DeliverTxResponse, QueryClient, StakingExtension, StargateClient, SigningStargateClientOptions } from '@cosmjs/stargate';
 import { Height } from 'cosmjs-types/ibc/core/client/v1/client';
-import { OfflineSigner as OfflineSigner$1 } from '@cosmjs/launchpad';
+import { OfflineSigner } from '@cosmjs/launchpad';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { UseQueryResult, QueryClientProviderProps } from '@tanstack/react-query';
 import { BondStatusString } from '@cosmjs/stargate/build/modules/staking/queries';
 import { QueryValidatorsResponse } from 'cosmjs-types/cosmos/staking/v1beta1/query';
+import { Tendermint34Client, Tendermint37Client } from '@cosmjs/tendermint-rpc';
 import { FC } from 'react';
 
 type Dictionary<T = string> = Record<string, T>;
@@ -33,7 +33,6 @@ interface GrazChain {
         price: string;
         denom: string;
     };
-    bech32Config: Bech32Config;
 }
 /**
  * Helper function to define chain information records (key values).
@@ -158,21 +157,6 @@ 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",
@@ -189,68 +173,69 @@ 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<{
-    chainId: string[];
+    chain?: GrazChain;
+    signerOpts?: SigningCosmWasmClientOptions;
     walletType?: WalletType;
     autoReconnect?: boolean;
 }>;
 interface ConnectResult {
+    account: Key;
     walletType: WalletType;
-    sessions: GrazAccountSession[];
+    chain: GrazChain;
 }
 declare const connect: (args?: ConnectArgs) => Promise<ConnectResult>;
+declare const disconnect: (clearRecentChain?: boolean) => Promise<void>;
+type ReconnectArgs = Maybe<{
+    onError?: (error: unknown) => void;
+}>;
+declare const reconnect: (args?: ReconnectArgs) => Promise<ConnectResult | undefined>;
 interface OfflineSigners {
-    offlineSigner: OfflineAminoSigner & OfflineDirectSigner$1;
+    offlineSigner: OfflineAminoSigner & OfflineDirectSigner;
     offlineSignerAmino: OfflineAminoSigner;
-    offlineSignerAuto: OfflineAminoSigner | OfflineDirectSigner$1;
+    offlineSignerAuto: OfflineAminoSigner | OfflineDirectSigner;
 }
 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>;
 
 declare const clearRecentChain: () => void;
-declare const getRecentChains: () => string[] | null;
+declare const getActiveChainCurrency: (denom: string) => AppCurrency | undefined;
+declare const getRecentChain: () => GrazChain | null;
 declare const suggestChain: (chainInfo: ChainInfo) => Promise<ChainInfo>;
 interface SuggestChainAndConnectArgs {
     chainInfo: ChainInfo;
-    autoReconnect?: boolean;
+    signerOpts?: SigningCosmWasmClientOptions;
     walletType?: WalletType;
+    gas?: {
+        price: string;
+        denom: string;
+    };
+    rpcHeaders?: Dictionary;
+    path?: string;
+    autoReconnect?: boolean;
+}
+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;
 }
-declare const suggestChainAndConnect: (args: SuggestChainAndConnectArgs) => Promise<ConnectResult>;
 
 interface ConfigureGrazArgs {
-    chains?: GrazChain[];
-    defaultClient?: GrazInternalStore["defaultClient"];
+    defaultChain?: GrazChain;
     defaultSigningClient?: GrazInternalStore["defaultSigningClient"];
     defaultWallet?: WalletType;
     onNotFound?: () => void;
@@ -261,29 +246,20 @@ interface ConfigureGrazArgs {
      */
     autoReconnect?: boolean;
 }
-declare const configureGraz: (args: ConfigureGrazArgs) => ConfigureGrazArgs;
+declare const configureGraz: (args?: ConfigureGrazArgs) => ConfigureGrazArgs;
 
-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;
+interface SendTokensArgs {
+    signingClient?: SigningStargateClient | SigningCosmWasmClient;
+    senderAddress?: string;
     recipientAddress: string;
     amount: Coin[];
     fee: number | StdFee | "auto";
     memo?: string;
 }
-declare const sendTokens: <T extends SigningClients>({ senderAddress, recipientAddress, amount, fee, memo, signingClient, }: SendTokensArgs<T>) => Promise<DeliverTxResponse>;
+declare const sendTokens: ({ signingClient, senderAddress, recipientAddress, amount, fee, memo, }: SendTokensArgs) => Promise<DeliverTxResponse>;
 interface SendIbcTokensArgs {
-    signingClient: ConnectSigningClient<"stargate">;
-    senderAddress: string;
+    signingClient?: SigningStargateClient;
+    senderAddress?: string;
     recipientAddress: string;
     transferAmount: Coin;
     sourcePort: string;
@@ -295,7 +271,7 @@ interface SendIbcTokensArgs {
 }
 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">;
+    signingClient?: SigningCosmWasmClient;
     msg: Message;
     label: string;
     fee: StdFee | "auto" | number;
@@ -308,7 +284,7 @@ type InstantiateContractMutationArgs<Message extends Record<string, unknown>> =
 };
 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">;
+    signingClient?: SigningCosmWasmClient;
     msg: Message;
     fee: StdFee | "auto" | number;
     senderAddress: string;
@@ -322,16 +298,8 @@ type ExecuteContractMutationArgs<Message extends Record<string, unknown>> = Omit
     memo?: string;
 };
 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>;
+declare const getQuerySmart: <TData>(address: string, queryMsg: Record<string, unknown>, client?: CosmWasmClient) => Promise<TData>;
+declare const getQueryRaw: (address: string, keyStr: string, client?: CosmWasmClient) => Promise<Uint8Array | null>;
 
 /**
  * Function to check whether given {@link WalletType} or default configured wallet exists.
@@ -442,9 +410,9 @@ interface AccountData {
 interface Connector {
     checkConnector: () => boolean;
     getAccount: (chainId: string, prefix?: string) => Promise<AccountData>;
-    getOfflineSigner: (chainId: string) => OfflineSigner$1 & OfflineDirectSigner;
-    getOfflineSignerOnlyAmino: (chainId: string) => OfflineSigner$1;
-    getOfflineSignerAuto: (chainId: string) => Promise<OfflineSigner$1 | OfflineDirectSigner>;
+    getOfflineSigner: (chainId: string) => OfflineSigner & OfflineDirectSigner;
+    getOfflineSignerOnlyAmino: (chainId: string) => OfflineSigner;
+    getOfflineSignerAuto: (chainId: string) => Promise<OfflineSigner | OfflineDirectSigner>;
 }
 interface GrazAdapter extends Connector {
     name: string;
@@ -452,25 +420,16 @@ 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;
 }
 
-type UseConnectOnConnect = GrazAccountSession & {
-    isReconnect: boolean;
-};
 interface UseAccountArgs {
-    onConnect?: (args: UseConnectOnConnect) => void;
+    onConnect?: (args: ConnectResult & {
+        isReconnect: boolean;
+    }) => void;
     onDisconnect?: () => void;
 }
 /**
@@ -491,7 +450,51 @@ interface UseAccountArgs {
  * });
  * ```
  */
-declare const useAccount: <T extends ChainIdArgs>(args?: (UseAccountArgs & T) | undefined) => HookResultDataWithChainId<GrazAccountSession | undefined, T> | undefined;
+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>;
 type UseConnectChainArgs = MutationEventArgs<ConnectArgs, ConnectResult>;
 /**
  * graz mutation hook to execute wallet connection with optional arguments to
@@ -534,7 +537,7 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
     isLoading: boolean;
     isSuccess: boolean;
     isSupported: boolean;
-    status: "error" | "idle" | "loading" | "success";
+    status: "error" | "success" | "loading" | "idle";
 };
 /**
  * graz mutation hook to execute wallet disconnection with optional arguments to
@@ -561,16 +564,12 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
  * @see {@link disconnect}
  */
 declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventArgs) => {
-    disconnect: (args?: {
-        chainid?: string[];
-    }) => void;
-    disconnectAsync: (args?: {
-        chainid?: string[];
-    }) => Promise<void>;
+    disconnect: (forget?: boolean) => void;
+    disconnectAsync: (forget?: boolean) => Promise<void>;
     error: unknown;
     isLoading: boolean;
     isSuccess: boolean;
-    status: "error" | "idle" | "loading" | "success";
+    status: "error" | "success" | "loading" | "idle";
 };
 /**
  * graz hook to retrieve offline signer objects (default, amino enabled, and auto).
@@ -580,11 +579,50 @@ declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventA
  * @example
  * ```ts
  * import { useOfflineSigners } from "graz";
- * const { signer, signerAmino, signerAuto } = useOfflineSigners();
+ * const { offlineSigner, offlineSignerAmino, offlineSignerAuto } = useOfflineSigners();
+ * ```
+ */
+declare const useOfflineSigners: () => UseQueryResult<OfflineSigners, unknown>;
+/**
+ * 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 useOfflineSigners: <T extends ChainIdArgs>(args?: T | undefined) => UseQueryResult<HookResultDataWithChainId<OfflineSigners, T> | undefined>;
+declare const useBalanceStaked: (bech32Address?: string) => UseQueryResult<Coin | null>;
 
+/**
+ * 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
  *
@@ -618,7 +656,7 @@ declare const useActiveChainValidators: <T extends QueryClient & StakingExtensio
  * @see {@link useActiveChain}
  */
 declare const useRecentChain: () => {
-    data: string[] | null;
+    data: GrazChain | null;
     clear: () => void;
 };
 type UseSuggestChainArgs = MutationEventArgs<ChainInfo>;
@@ -644,7 +682,7 @@ declare const useSuggestChain: ({ onError, onLoading, onSuccess }?: UseSuggestCh
     isSuccess: boolean;
     suggest: _tanstack_react_query.UseMutateFunction<ChainInfo, unknown, ChainInfo, unknown>;
     suggestAsync: _tanstack_react_query.UseMutateAsyncFunction<ChainInfo, unknown, ChainInfo, unknown>;
-    status: "error" | "idle" | "loading" | "success";
+    status: "error" | "success" | "loading" | "idle";
 };
 type UseSuggestChainAndConnectArgs = MutationEventArgs<SuggestChainAndConnectArgs, ConnectResult>;
 /**
@@ -682,109 +720,268 @@ declare const useSuggestChainAndConnect: ({ onError, onLoading, onSuccess }?: Us
     isLoading: boolean;
     isSuccess: boolean;
     isSupported: boolean;
-    status: "error" | "idle" | "loading" | "success";
+    status: "error" | "success" | "loading" | "idle";
     suggestAndConnect: _tanstack_react_query.UseMutateFunction<ConnectResult, unknown, SuggestChainAndConnectArgs, unknown>;
     suggestAndConnectAsync: _tanstack_react_query.UseMutateAsyncFunction<ConnectResult, unknown, SuggestChainAndConnectArgs, unknown>;
 };
 
 /**
- * graz query hook to retrieve a CosmWasmClient, StargateClient and Tendermint34Client. If there's no given arguments it will be using the current connected client
+ * graz query hook to retrieve a StargateClient.
  *
  * @example
  * ```ts
- * import { useClient } from "graz";
+ * import { useStargateClient } from "graz";
+ *
+ * const { data:client, isFetching, refetch, ... } = useStargateClient();
  *
- * // use connected client's cosmwasm client
- * const { data, isFetching, refetch, ... } = useClient();
+ * client.getAccount("address")
  *
- * // initialize new custom client from given arguments
- * useClient({ rpc: "https://rpc.cosmoshub.strange.love", });
  * ```
  */
-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>;
+declare const useStargateClient: () => UseQueryResult<StargateClient, unknown>;
 /**
- * graz query hook to retrieve a SigningCosmWasmClient. If there's no given args it will be using the current connected signer
+ * graz query hook to retrieve a CosmWasmClient.
  *
  * @example
  * ```ts
- * import { useSigningClient } from "graz";
+ * import { useCosmWasmClient } from "graz";
  *
- * // get connected client's cosmwasm client
- * const { data, isFetching, refetch, ... } = useSigningClient();
+ * const { data:client, isFetching, refetch, ... } = useCosmWasmClient();
+ *
+ * client.getAccount("address")
  *
- * // initialize new custom client with given args
- * useSigningClient({
- *   rpc: "https://rpc.cosmoshub.strange.love",
- *   offlineSigner: customOfflineSigner,
- *   ...
- * });
  * ```
  */
-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>;
-
+declare const useCosmWasmClient: () => UseQueryResult<CosmWasmClient, unknown>;
 /**
- * graz query hook to retrieve list of balances from current account or given address.
+ * graz query hook to retrieve a TendermintClient.
  *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
+ * @example
+ * ```ts
+ * import { useCosmWasmClient } from "graz";
+ *
+ * const { data:client, isFetching, refetch, ... } = useTendermintClient("tm37");
+ *
+ * client.getAccount("address")
+ *
+ * ```
+ */
+declare const useTendermintClient: <T extends "tm34" | "tm37">(type: T) => UseQueryResult<T extends "tm34" ? Tendermint34Client : Tendermint37Client>;
+
+/**
+ * graz mutation hook to send tokens. Note: if `senderAddress` undefined, it will use current connected account address.
  *
  * @example
  * ```ts
- * import { useBalances } from "graz";
+ * import { useSendTokens, useStargateSigningClient } from "graz";
  *
  * // basic example
- * const { data, isFetching, refetch, ... } = useBalances();
+ * const { data: signingClient } = useStargateSigningClient()
+ * const { sendTokens } = useSendTokens();
  *
- * // with custom bech32 address
- * useBalances("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
+ * sendTokens({
+ *    signingClient,
+ *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430";
+ *    amount: [coin];
+ *    ...
+ * })
  * ```
+ *
+ * @see {@link sendTokens}
  */
-declare const useBalances: <T extends "cosmWasm" | "stargate", U extends ChainIdArgs>(args: {
-    bech32Address?: string | undefined;
-    client?: T | undefined;
-} & U) => UseQueryResult<HookResultDataWithChainId<Coin$1[], U>>;
+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" | "success" | "loading" | "idle";
+};
 /**
- * graz query hook to retrieve list of staked balances from current account or given address.
+ * graz mutation hook to send IBC 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 { useBalanceStaked } from "graz";
+ * import { useSendIbcTokens, useStargateSigningClient } from "graz";
  *
  * // basic example
- * const { data, isFetching, refetch, ... } = useBalanceStaked();
+ * const { data: signingClient } = useStargateSigningClient()
+ * const { sendIbcTokens } = useSendIbcTokens();
  *
- * // with custom bech32 address
- * useBalanceStaked("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
+ * sendIbcTokens({
+ *    signingClient,
+ *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430",
+ *    transferAmount: coin,
+ *    ...
+ * })
  * ```
  */
-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;
-}) => {
+declare const useSendIbcTokens: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SendIbcTokensArgs, DeliverTxResponse>) => {
     error: unknown;
     isLoading: boolean;
     isSuccess: boolean;
-    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";
+    sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, unknown, SendIbcTokensArgs, unknown>;
+    sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, unknown, SendIbcTokensArgs, unknown>;
+    status: "error" | "success" | "loading" | "idle";
 };
+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, useCosmwasmSigningClient } from "graz"
+ *
+ * const { data: signingClient } = useCosmwasmSigningClient()
+ * const { instantiateContract: instantiateMyContract } = useInstantiateContract({
+ *   codeId: 4,
+ *   onSuccess: ({ contractAddress }) => console.log('Address:', contractAddress)
+ * })
+ *
+ * const instantiateMessage = { foo: 'bar' };
+ * instantiateMyContract({
+ *  signingClient,
+ *  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" | "success" | "loading" | "idle";
+};
+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, useCosmwasmSigningClient } from "graz"
+ *
+ * interface GreetMessage {
+ *   name: string;
+ * }
+ *
+ * interface GreetResponse {
+ *   message: string;
+ * }
+ *
+ * const contractAddress = "cosmosfoobarbaz";
+ *
+ * const { data: signingClient } = useCosmwasmSigningClient()
+ * const { executeContract } = useExecuteContract<ExecuteMessage>({ contractAddress });
+ *
+ * executeContract({
+ *  signingClient,
+ *  msg: {
+ *    foo: "bar"
+ *  }}, {
+ *    onSuccess: (data: GreetResponse) => console.log('Got message:', data.message);
+ *  });
+ * ```
+ */
+declare const useExecuteContract: <Message extends Record<string, unknown>>({ contractAddress, onError, onLoading, onSuccess, }: UseExecuteContractArgs<Message>) => {
+    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>;
+    status: "error" | "success" | "loading" | "idle";
+};
+/**
+ * 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 query hook to retrieve a SigningStargateClient.
+ *
+ * @example
+ * ```ts
+ * import { useStargateSigningClient } from "graz";
+ *
+ * const { data:signingClient, isFetching, refetch, ... } = useStargateSigningClient();
+ *
+ * signingClient.getAccount("address")
+ *
+ * ```
+ */
+declare const useStargateSigningClient: (args?: {
+    opts?: SigningStargateClientOptions;
+}) => _tanstack_react_query.UseQueryResult<SigningStargateClient, unknown>;
+/**
+ * graz query hook to retrieve a SigningCosmWasmClient.
+ *
+ * @example
+ * ```ts
+ * import { useCosmWasmSigningClient } from "graz";
+ *
+ * const { data:signingClient, isFetching, refetch, ... } = useCosmWasmSigningClient();
+ *
+ * signingClient.getAccount("address")
+ *
+ * ```
+ */
+declare const useCosmWasmSigningClient: (args?: {
+    opts?: SigningCosmWasmClientOptions;
+}) => _tanstack_react_query.UseQueryResult<SigningCosmWasmClient, unknown>;
+/**
+ * graz query hook to retrieve a SigningStargateClient with tendermint client.
+ *
+ * @example
+ * ```ts
+ * import { useStargateTmSigningClient } from "graz";
+ *
+ * const { data:signingClient, isFetching, refetch, ... } = useStargateTmSigningClient("tm34");
+ *
+ * signingClient.getAccount("address")
+ *
+ * ```
+ */
+declare const useStargateTmSigningClient: (args: {
+    type: "tm34" | "tm37";
+    opts?: SigningStargateClientOptions;
+}) => _tanstack_react_query.UseQueryResult<SigningStargateClient, unknown>;
+/**
+ * graz query hook to retrieve a SigningCosmWasmClient with tendermint client.
+ *
+ * @example
+ * ```ts
+ * import { useCosmWasmTmSigningClient } from "graz";
+ *
+ * const { data:signingClient, isFetching, refetch, ... } = useCosmWasmTmSigningClient("tm34");
+ *
+ * signingClient.getAccount("address")
+ *
+ * ```
+ */
+declare const useCosmWasmTmSigningClient: (args: {
+    type: "tm34" | "tm37";
+    opts?: SigningCosmWasmClientOptions;
+}) => _tanstack_react_query.UseQueryResult<SigningCosmWasmClient, unknown>;
 
 /**
  * graz hook to retrieve current active {@link WalletType}
@@ -819,24 +1016,9 @@ 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 GrazConfig = Omit<ConfigureGrazArgs, "chains"> & {
-    chains: GrazChain[];
-};
 type GrazProviderProps = Partial<QueryClientProviderProps> & {
-    grazConfig: GrazConfig;
+    grazOptions?: ConfigureGrazArgs;
+    debug?: boolean;
 };
 /**
  * Provider component which extends `@tanstack/react-query`'s {@link QueryClientProvider} with built-in query client
@@ -858,4 +1040,17 @@ type GrazProviderProps = Partial<QueryClientProviderProps> & {
  */
 declare const GrazProvider: FC<GrazProviderProps>;
 
-export { AccountData, ChainInfoWithPath, Clients, ConfigureGrazArgs, ConnectArgs, ConnectClient, ConnectClientArgs, ConnectResult, ConnectSigningClient, ConnectSigningClientArgs, Connector, Dictionary, ExecuteContractArgs, ExecuteContractMutationArgs, GetWalletConnectParams, GrazAdapter, GrazChain, GrazConfig, GrazEvents, GrazProvider, GrazProviderProps, InstantiateContractArgs, InstantiateContractMutationArgs, Maybe, OfflineSigners, ReconnectArgs, SendIbcTokensArgs, SendTokensArgs, SigningClients, SuggestChainAndConnectArgs, 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 };
+/**
+ * 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, Dictionary, ExecuteContractArgs, ExecuteContractMutationArgs, GetWalletConnectParams, GrazAdapter, GrazChain, GrazEvents, GrazProvider, GrazProviderProps, InstantiateContractArgs, InstantiateContractMutationArgs, Maybe, OfflineSigners, ReconnectArgs, SendIbcTokensArgs, SendTokensArgs, SuggestChainAndConnectArgs, UseAccountArgs, UseConnectChainArgs, UseExecuteContractArgs, UseInstantiateContractArgs, UseSuggestChainAndConnectArgs, UseSuggestChainArgs, WALLET_TYPES, Wallet, WalletType, checkWallet, clearRecentChain, configureGraz, connect, defineChain, defineChainInfo, defineChains, disconnect, executeContract, getActiveChainCurrency, getAvailableWallets, getCosmostation, getKeplr, getLeap, getOfflineSigners, 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, useConnect, useCosmWasmClient, useCosmWasmSigningClient, useCosmWasmTmSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryRaw, useQuerySmart, useRecentChain, useSendIbcTokens, useSendTokens, useStargateClient, useStargateSigningClient, useStargateTmSigningClient, useSuggestChain, useSuggestChainAndConnect, useTendermintClient };