graz 0.0.45-alpha.2 → 0.1.0-alpha.2

package/dist/index.d.ts

@@ -1,8 +1,9 @@
+import * as _keplr_wallet_types from '@keplr-wallet/types';
 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 { CosmWasmClient, SigningCosmWasmClientOptions, SigningCosmWasmClient, InstantiateOptions } from '@cosmjs/cosmwasm-stargate';
+import { CosmWasmClient, SigningCosmWasmClientOptions, SigningCosmWasmClient, InstantiateOptions, InstantiateResult, ExecuteResult } 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';
@@ -263,11 +264,15 @@ interface ConfigureGrazArgs {
 }
 declare const configureGraz: (args: ConfigureGrazArgs) => ConfigureGrazArgs;
 
-declare const getBalances: <T extends "cosmWasm" | "stargate">({ bech32Address, client, currencies, }: {
-    currencies: AppCurrency[];
+declare const getAllBalance: <T extends "stargate">({ bech32Address, client, }: {
     bech32Address: string;
     client: ConnectClient<T>;
 }) => Promise<Coin[]>;
+declare const getBalance: <T extends "cosmWasm" | "stargate">({ bech32Address, client, searchDenom, }: {
+    searchDenom: string;
+    bech32Address: string;
+    client: ConnectClient<T>;
+}) => Promise<Coin>;
 declare const getBalanceStaked: ({ bech32Address, client, }: {
     bech32Address: string;
     client: ConnectClient<"stargate">;
@@ -303,7 +308,7 @@ interface InstantiateContractArgs<Message extends Record<string, unknown>> {
     senderAddress: string;
     codeId: number;
 }
-type InstantiateContractMutationArgs<Message extends Record<string, unknown>> = Omit<InstantiateContractArgs<Message>, "codeId" | "senderAddress" | "fee"> & {
+type InstantiateContractMutationArgs<Message extends Record<string, unknown>> = Omit<InstantiateContractArgs<Message>, "codeId" | "senderAddress" | "fee" | "signingClient"> & {
     fee?: StdFee | "auto" | number;
 };
 declare const instantiateContract: <Message extends Record<string, unknown>>({ signingClient, senderAddress, msg, fee, options, label, codeId, }: InstantiateContractArgs<Message>) => Promise<_cosmjs_cosmwasm_stargate.InstantiateResult>;
@@ -316,7 +321,7 @@ interface ExecuteContractArgs<Message extends Record<string, unknown>> {
     funds: Coin[];
     memo: string;
 }
-type ExecuteContractMutationArgs<Message extends Record<string, unknown>> = Omit<ExecuteContractArgs<Message>, "contractAddress" | "senderAddress" | "fee" | "funds" | "memo"> & {
+type ExecuteContractMutationArgs<Message extends Record<string, unknown>> = Omit<ExecuteContractArgs<Message>, "contractAddress" | "senderAddress" | "fee" | "funds" | "memo" | "signingClient"> & {
     fee?: StdFee | "auto" | number;
     funds?: Coin[];
     memo?: string;
@@ -474,8 +479,11 @@ interface UseAccountArgs {
     onDisconnect?: () => void;
 }
 /**
- * graz query hook to retrieve account data with optional arguments to invoke
- * given function on connect/disconnect.
+ * graz query hook to retrieve account data
+ *
+ * @param chainId - if provided, it will only return the data of the given chainId
+ * @param onConnect - callback function when the account is connected
+ * @param onDisconnect - callback function when the account is disconnected
  *
  * @example
  * ```tsx
@@ -497,6 +505,10 @@ type UseConnectChainArgs = MutationEventArgs<ConnectArgs, ConnectResult>;
  * graz mutation hook to execute wallet connection with optional arguments to
  * invoke given functions on error, loading, or success event.
  *
+ * @param onError - callback function when the connection is failed
+ * @param onLoading - callback function when the connection is loading
+ * @param onSuccess - callback function when the connection is successful
+ *
  * @example
  * ```ts
  * import { useConnect, mainnetChains } from "graz";
@@ -540,6 +552,10 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
  * graz mutation hook to execute wallet disconnection with optional arguments to
  * invoke given functions on error, loading, or success event.
  *
+ * @param onError - callback function when the disconnection is failed
+ * @param onLoading - callback function when the disconnection is loading
+ * @param onSuccess - callback function when the disconnection is successful
+ *
  * @example
  * ```ts
  * import { useDisconnect } from "graz";
@@ -554,8 +570,11 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
  *   onSuccess: () => { ... },
  * });
  *
- * // pass `true` on disconnect to clear recent connected chain
- * disconnect(true);
+ * //disconnect all chains
+ * disconnect();
+ *
+ * //disconnect specific chains
+ * disconnect({ chainid: ["cosmoshub-4", "juno-1"] });
  * ```
  *
  * @see {@link disconnect}
@@ -575,12 +594,21 @@ declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventA
 /**
  * graz hook to retrieve offline signer objects (default, amino enabled, and auto).
  *
- * Note: signer objects is initialized after connecting an account.
+ * @param chainId - chain id arguments
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
  *
  * @example
  * ```ts
  * import { useOfflineSigners } from "graz";
- * const { signer, signerAmino, signerAuto } = useOfflineSigners();
+ *
+ * // single chain
+ * const { offlineSigner, offlineSignerAmino, offlineSignerAuto } = useOfflineSigners({ chainId: "cosmoshub-4" });
+ *
+ * // multi chain
+ * const offlineSigners = useOfflineSigners();
+ * offlineSigners["cosmoshub-4"].offlineSignerAuto;
+ *
  * ```
  */
 declare const useOfflineSigners: <T extends ChainIdArgs>(args?: T | undefined) => UseQueryResult<HookResultDataWithChainId<OfflineSigners, T> | undefined>;
@@ -614,8 +642,6 @@ declare const useActiveChainValidators: <T extends QueryClient & StakingExtensio
  *   connect(recentChain);
  * }
  * ```
- *
- * @see {@link useActiveChain}
  */
 declare const useRecentChain: () => {
     data: string[] | null;
@@ -686,19 +712,47 @@ declare const useSuggestChainAndConnect: ({ onError, onLoading, onSuccess }?: Us
     suggestAndConnect: _tanstack_react_query.UseMutateFunction<ConnectResult, unknown, SuggestChainAndConnectArgs, unknown>;
     suggestAndConnectAsync: _tanstack_react_query.UseMutateAsyncFunction<ConnectResult, unknown, SuggestChainAndConnectArgs, unknown>;
 };
+/**
+ * graz hook to retrieve chain data and usefull functions with given chainId
+ * @param chainId - Chain ID string
+ *
+ * @example
+ * ```ts
+ * import { useChain } from "graz";
+ * const { data: chain } = useChain("cosmoshub-4");
+ * ```
+ */
+declare const useChain: ({ chainId }: {
+    chainId: string;
+}) => {
+    convertMinimalDenomToDenom: (searchMinimalDenom: string, value: string) => {
+        denom: string;
+        value: number;
+    } | undefined;
+    currencies: _keplr_wallet_types.AppCurrency[];
+    data: GrazChain;
+} | undefined;
 
 /**
- * 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 CosmWasmClient or StargateClient or Tendermint34Client.
+ *
+ * @param client - if provided, it will use the given client instead of the default client
+ * @param chainId - if provided, it will only return the data of the given chainId
+ * @param onlyConnectedChains - if true, it will only return the client of the current connected chains
+ * @param enabled - if false, it will not fetch the data
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
  *
  * @example
  * ```ts
  * import { useClient } from "graz";
  *
- * // use connected client's cosmwasm client
- * const { data, isFetching, refetch, ... } = useClient();
+ * // single chain
+ * const { data, isLoading, ... } = useClient({ client: "stargate" chainId: "cosmoshub-4" });
+ *
+ * // all chains from GrazProvider example
+ * const { data, isLoading, ... } = useClient({ client: "stargate" });
  *
- * // initialize new custom client from given arguments
- * useClient({ rpc: "https://rpc.cosmoshub.strange.love", });
  * ```
  */
 declare const useConnectClient: <T extends Clients, U extends ChainIdArgs>(args?: ({
@@ -711,21 +765,24 @@ declare const useConnectClient: <T extends Clients, U extends ChainIdArgs>(args?
     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
+ * graz query hook to retrieve a SigningCosmWasmClient or SigningStargateClient.
+ *
+ * @param client - if provided, it will use the given client instead of the default client
+ * @param chainId - if provided, it will only return the data of the given chainId
+ * @param options - signing client options of given client
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
  *
  * @example
  * ```ts
  * import { useSigningClient } from "graz";
  *
- * // get connected client's cosmwasm client
- * const { data, isFetching, refetch, ... } = useSigningClient();
+ * // single chain
+ * const { data, isLoading, ... } = useSigningClient({ client: "stargate" chainId: "cosmoshub-4" });
+ *
+ * // all chains from GrazProvider example
+ * const { data, isLoading, ... } = useSigningClient({ client: "stargate" });
  *
- * // 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?: ({
@@ -734,50 +791,151 @@ declare const useConnectSigningClient: <T extends SigningClients, U extends Chai
 } & U) | undefined) => UseQueryResult<HookResultDataWithChainId<ConnectSigningClient<T>, U> | undefined>;
 
 /**
- * graz query hook to retrieve list of balances from current account or given address.
+ * graz query hook to retrieve balance from given address, denom and chainId
  *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
+ * @param bech32Address - Optional bech32 address, if not provided will return undefined
+ * @param searchDenom - Optional search denom, if not provided will return undefined
+ * @param chainId - Required chainId to retrieve the balances from given address
+ * @param client - Optional client, if not provided will use the default client
  *
  * @example
  * ```ts
- * import { useBalances } from "graz";
+ * import { useBalance } from "graz";
  *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalances();
+ * const { data, isFetching, refetch, ... } = useBalance({
+ *  client: "stargate",
+ *  chainId: "cosmoshub-4",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * })
+ *
+ * ```
+ */
+declare const useBalance: <T extends "cosmWasm" | "stargate">(args: {
+    bech32Address?: string | undefined;
+    client?: T | undefined;
+    chainId: string;
+    searchDenom?: string | undefined;
+}) => UseQueryResult<Coin$1 | undefined>;
+/**
+ * graz query hook to retrieve list of balances from given address.
+ *
+ * @param bech32Address - Optional bech32 address, if not provided will return undefined
+ * @param chainId - Optional chainId to retrieve the balances from given address and chainId, if not provided will return all balances currencies from all chains provided from GrazProvider
+ * @param client - Optional client, if not provided will use the default client
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
  *
- * // with custom bech32 address
- * useBalances("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
+ * @example
+ * ```ts
+ * import { useAllBalances } from "graz";
+ *
+ * // single chain example
+ * const { data, isFetching, refetch, ... } = useAllBalances({
+ *  client: "stargate",
+ *  chainId: "cosmoshub-4",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * })
+ *
+ * // all chains from GrazProvider example
+ * const { data, isFetching, refetch, ... } = useAllBalances({
+ *  client: "stargate",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * })
  * ```
  */
-declare const useBalances: <T extends "cosmWasm" | "stargate", U extends ChainIdArgs>(args: {
+declare const useAllBalances: <U extends ChainIdArgs>(args: {
+    bech32Address?: string | undefined;
+} & U) => UseQueryResult<HookResultDataWithChainId<Coin$1[] | undefined, U>>;
+/**
+ * graz query hook to retrieve list of currencies from defined chains in GrazProvider and given address.
+ *
+ * @param bech32Address - Optional bech32 address, if not provided will return undefined
+ * @param client - Optional client, if not provided will use the default client
+ * @param chainId - Optional chainId to retrieve the balances from given address and chainId, if not provided will return all balances currencies from all chains provided from GrazProvider
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
+ *
+ * @example
+ * ```ts
+ * import { useChainBalances } from "graz";
+ *
+ * // single chain example
+ * const { data, isFetching, refetch, ... } = useChainBalances({
+ *  client: "stargate",
+ *  chainId: "cosmoshub-4",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * })
+ *
+ * // all chains from GrazProvider example
+ * const { data, isFetching, refetch, ... } = useChainBalances({
+ *  client: "stargate",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * })
+ * ```
+ */
+declare const useChainBalances: <T extends "cosmWasm" | "stargate", U extends ChainIdArgs>(args: {
     bech32Address?: string | undefined;
     client?: T | undefined;
 } & U) => UseQueryResult<HookResultDataWithChainId<Coin$1[], U>>;
 /**
  * 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
+ * @param bech32Address - Optional bech32 account address, if not provided will return undefined
+ * @param chainId - Optional chainId to retrieve the balances from given address and chainId, if not provided will return all balances currencies from all chains provided from GrazProvider
+ *
+ * @returns if chainId is string it will return an object, otherwise it will return a record of objects
  *
  * @example
  * ```ts
  * import { useBalanceStaked } from "graz";
  *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalanceStaked();
+ * // single chain example
+ * const { data, isFetching, refetch, ... } = useBalanceStaked({
+ *  chainId: "cosmoshub-4",
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * });
  *
- * // with custom bech32 address
- * useBalanceStaked("cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
+ * // all chains from GrazProvider example
+ * const { data, isFetching, refetch, ... } = useBalanceStaked({
+ *  bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu",
+ * });
  * ```
  */
-declare const useBalanceStaked: <T extends "stargate", U extends ChainIdArgs>(args: {
+declare const useBalanceStaked: <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;
+interface UseSendTokens<T extends SigningClients> {
+    signingClient?: T;
+    signingClientOptions?: ConnectSigningClientArgs<T>["options"];
     chainId: string;
-}) => {
+}
+/**
+ * graz mutation hook to send tokens.
+ *
+ * @param signingClient - Optional ("stargate" | "cosmWasm") signing client to use, if not provided will use default signing client from GrazProvider
+ * @param signingClientOptions - Optional signing client options to use.
+ * @param chainId - Required chainId to send tokens to.
+ * @param onError - Optional error callback function.
+ * @param onLoading - Optional loading callback function.
+ * @param onSuccess - Optional success callback function.
+ *
+ * @example
+ * ```ts
+ * import { useSendTokens } from "graz";
+ *
+ * // basic example
+ * const { sendTokens } = useSendTokens();
+ *
+ * sendTokens({
+ *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430";
+ *    amount: [coin];
+ *    ...
+ * })
+ * ```
+ *
+ * @see {@link sendTokens}
+ */
+declare const useSendTokens: <T extends SigningClients>({ signingClient, signingClientOptions, chainId, onError, onLoading, onSuccess, }: MutationEventArgs<SendTokensArgs<T>, DeliverTxResponse> & UseSendTokens<T>) => {
     error: unknown;
     isLoading: boolean;
     isSuccess: boolean;
@@ -785,6 +943,154 @@ declare const useSendTokens: <T extends SigningClients>({ signingClient, signing
     sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, unknown, SendTokensArgs<T>, unknown>;
     status: "error" | "idle" | "loading" | "success";
 };
+interface UseSendIbcTokens {
+    signingClientOptions?: ConnectSigningClientArgs<"stargate">["options"];
+    chainId: string;
+}
+/**
+ * graz mutation hook to send IBC tokens.
+ *
+ * @param chainId - Required chainId to send tokens to.
+ * @param signingClientOptions - Optional signing client options to use.
+ * @param onError - Optional error callback function.
+ * @param onLoading - Optional loading callback function.
+ * @param onSuccess - Optional success callback function.
+ *
+ * @example
+ * ```ts
+ * import { useSendIbcTokens } from "graz";
+ *
+ * // basic example
+ * const { sendIbcTokens } = useSendIbcTokens();
+ *
+ * sendIbcTokens({
+ *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430",
+ *    transferAmount: coin,
+ *    ...
+ * })
+ * ```
+ */
+declare const useSendIbcTokens: ({ chainId, signingClientOptions, onError, onLoading, onSuccess, }: MutationEventArgs<SendIbcTokensArgs, DeliverTxResponse> & UseSendIbcTokens) => {
+    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;
+    chainId: string;
+    signingClientOptions?: ConnectSigningClientArgs<"cosmWasm">["options"];
+} & MutationEventArgs<InstantiateContractMutationArgs<Message>, InstantiateResult>;
+/**
+ * graz mutation hook to instantiate a CosmWasm smart contract when supported.
+ *
+ * @param codeId - Required codeId to instantiate.
+ * @param chainId - Required chainId to instantiate contract on.
+ * @param signingClientOptions - Optional signing client options to use.
+ * @param onError - Optional error callback function.
+ * @param onLoading - Optional loading callback function.
+ * @param onSuccess - Optional success callback function.
+ *
+ * @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>>({ chainId, codeId, signingClientOptions, 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;
+    chainId: string;
+    signingClientOptions?: ConnectSigningClientArgs<"cosmWasm">["options"];
+} & MutationEventArgs<ExecuteContractMutationArgs<Message>, ExecuteResult>;
+/**
+ * graz mutation hook for executing transactions against a CosmWasm smart
+ * contract.
+ *
+ * @param contractAddress - Required contractAddress to execute against.
+ * @param chainId - Required chainId to execute contract on.
+ * @param signingClientOptions - Optional signing client options to use.
+ * @param onError - Optional error callback function.
+ * @param onLoading - Optional loading callback function.
+ * @param onSuccess - Optional success callback function.
+ *
+ * @example
+ * ```ts
+ * import { useExecuteContract } from "graz"
+ *
+ * interface GreetMessage {
+ *   name: string;
+ * }
+ *
+ * interface GreetResponse {
+ *   message: string;
+ * }
+ *
+ * const contractAddress = "cosmosfoobarbaz";
+ * const { executeContract } = useExecuteContract<ExecuteMessage>({ contractAddress });
+ * executeContract({ msg: {
+ *   foo: "bar"
+ * }}, {
+ *   onSuccess: (data: GreetResponse) => console.log('Got message:', data.message);
+ * });
+ * ```
+ */
+declare const useExecuteContract: <Message extends Record<string, unknown>>({ chainId, contractAddress, signingClientOptions, 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" | "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
+ * @param chainId - The chainId to query on
+ *
+ * @returns A query result with the result returned by the smart contract.
+ */
+declare const useQuerySmart: <TData, TError>({ address, queryMsg, chainId, }: {
+    address?: string | undefined;
+    queryMsg?: Record<string, unknown> | undefined;
+    chainId: string;
+}) => 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
+ * @param chainId - The chainId to query on
+ *
+ * @returns A query result with raw byte array stored at the key queried.
+ */
+declare const useQueryRaw: <TError>({ address, key, chainId, }: {
+    address?: string | undefined;
+    key?: string | undefined;
+    chainId: string;
+}) => UseQueryResult<Uint8Array | null, TError>;
 
 /**
  * graz hook to retrieve current active {@link WalletType}
@@ -858,4 +1164,12 @@ 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 };
+declare const convertMicroDenomToDenom: (value: number | string, decimals: number) => number;
+declare const convertDenomToMicroDenom: (value: number | string, decimals: number) => number;
+declare const convertFromMicroDenom: (denom: string) => string;
+declare const convertToFixedDecimals: (value: number | string, fractionDigits?: number) => string;
+declare const formatTokenName: (name: string) => string;
+declare const handleNaN: (value: number) => number;
+declare const truncate: (string?: string, slice?: number) => string;
+
+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, UseExecuteContractArgs, UseInstantiateContractArgs, UseSendIbcTokens, UseSuggestChainAndConnectArgs, UseSuggestChainArgs, WALLET_TYPES, Wallet, WalletType, checkWallet, clearRecentChain, configureGraz, connect, connectClient, connectSigningClient, convertDenomToMicroDenom, convertFromMicroDenom, convertMicroDenomToDenom, convertToFixedDecimals, defineChain, defineChainInfo, defineChains, disconnect, executeContract, formatTokenName, getAllBalance, getAvailableWallets, getBalance, getBalanceStaked, getCosmostation, getKeplr, getLeap, getOfflineSigners, getQueryRaw, getQuerySmart, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, handleNaN, instantiateContract, mainnetChains, mainnetChainsArray, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, testnetChains, testnetChainsArray, truncate, useAccount, useActiveChainValidators, useActiveWalletType, useAllBalances, useBalance, useBalanceStaked, useChain, useChainBalances, useCheckWallet, useConnect, useConnectClient, useConnectSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryRaw, useQuerySmart, useRecentChain, useSendIbcTokens, useSendTokens, useSuggestChain, useSuggestChainAndConnect };