graz 0.3.7 → 0.4.0-alpha.0

package/dist/index.d.ts

@@ -2,9 +2,9 @@
 import { DirectSignResponse, OfflineDirectSigner, Coin } from '@cosmjs/proto-signing';
 import { Key as Key$1, Keplr, ChainInfo, KeplrSignOptions, KeplrIntereactionOptions, OfflineAminoSigner as OfflineAminoSigner$1, AppCurrency } from '@keplr-wallet/types';
 import { OfflineAminoSigner } from '@cosmjs/amino';
-import { SignClientTypes } from '@walletconnect/types';
-import { WalletConnectModalConfig } from '@walletconnect/modal';
 import { ParaGrazConfig as ParaGrazConfig$1, ParaGrazConnector } from '@getpara/graz-connector';
+import { WalletConnectModalConfig } from '@walletconnect/modal';
+import { SignClientTypes } from '@walletconnect/types';
 import * as _cosmjs_cosmwasm_stargate from '@cosmjs/cosmwasm-stargate';
 import { SigningCosmWasmClient, InstantiateOptions, CosmWasmClient, InstantiateResult, ExecuteResult, SigningCosmWasmClientOptions } from '@cosmjs/cosmwasm-stargate';
 import { SigningStargateClient, StdFee, DeliverTxResponse, QueryClient, StakingExtension, StargateClient, SigningStargateClientOptions } from '@cosmjs/stargate';
@@ -36,7 +36,8 @@ declare enum WalletType {
     COMPASS = "compass",
     INITIA = "initia",
     OKX = "okx",
-    PARA = "para"
+    PARA = "para",
+    CACTUSCOSMOS = "cactuscosmos"
 }
 declare const WALLET_TYPES: WalletType[];
 type Wallet = Pick<Keplr, "enable" | "getOfflineSignerOnlyAmino" | "signAmino"> & {
@@ -66,14 +67,13 @@ type SignAminoParams = Parameters<Wallet["signAmino"]>;
 type KnownKeys = Record<string, Key>;
 type Key = Omit<Key$1, "ethereumHexAddress">;
 
-type ChainId$1 = string | string[];
-interface MultiChainHookArgs {
-    chainId?: ChainId$1;
-    multiChain?: boolean;
-}
-
+/**
+ * Chain ID type for actions - supports both string and string[] for backward compatibility.
+ * Actions normalize this internally to string[].
+ */
+type ActionChainId = string | string[];
 type ConnectArgs = Maybe<{
-    chainId: ChainId$1;
+    chainId: ActionChainId;
     walletType?: WalletType;
     autoReconnect?: boolean;
 }>;
@@ -84,7 +84,7 @@ interface ConnectResult {
 }
 declare const connect: (args?: ConnectArgs) => Promise<ConnectResult>;
 declare const disconnect: (args?: {
-    chainId?: ChainId$1;
+    chainId?: ActionChainId;
 }) => Promise<void>;
 type ReconnectArgs = Maybe<{
     onError?: (error: unknown) => void;
@@ -103,12 +103,16 @@ declare const getOfflineSigners: (args?: {
 declare const clearRecentChain: () => void;
 declare const getRecentChainIds: () => string[] | null;
 declare const getRecentChains: () => ChainInfo[] | null;
-declare const getChainInfo: ({ chainId }: {
+declare const getChainInfo: ({ chainId }?: {
     chainId?: string;
 }) => ChainInfo | undefined;
-declare const getChainInfos: ({ chainId }: {
+declare const getChainInfos: ({ chainId }?: {
     chainId?: string[];
 }) => ChainInfo[] | undefined;
+interface AddChainArgs {
+    chainInfo: ChainInfo;
+}
+declare const addChain: ({ chainInfo }: AddChainArgs) => Promise<ChainInfo>;
 interface SuggestChainArgs {
     chainInfo: ChainInfo;
     walletType: WalletType;
@@ -157,7 +161,8 @@ interface GrazInternalStore {
     chainsConfig: Record<string, ChainConfig> | null;
     iframeOptions: IframeOptions | null;
     /**
-     * Graz will use this number to determine how many concurrent requests to make when using `multiChain` args in hooks.
+     * Graz will use this number to determine how many concurrent requests to make when querying multiple chains.
+     * All hooks now operate on multiple chains by default (returning Record<chainId, T>).
      * Defaults to 3.
      */
     multiChainFetchConcurrency: number;
@@ -188,7 +193,8 @@ interface ConfigureGrazArgs {
      */
     autoReconnect?: boolean;
     /**
-     * Graz will use this number to determine how many concurrent requests to make when using `multiChain` args in hooks.
+     * Graz will use this number to determine how many concurrent requests to make when querying multiple chains.
+     * All hooks now operate on multiple chains by default (returning Record<chainId, T>).
      * Defaults to 3.
      */
     multiChainFetchConcurrency?: number;
@@ -231,7 +237,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" | "fee"> & {
     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>;
@@ -244,7 +250,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" | "fee" | "funds" | "memo"> & {
     fee?: StdFee | "auto" | number;
     funds?: Coin[];
     memo?: string;
@@ -283,6 +289,9 @@ declare const isLeapDappBrowser: () => boolean;
 declare const isWalletConnect: (type: WalletType) => boolean;
 declare const isPara: (type: WalletType) => type is WalletType.PARA;
 
+type CactusCosmosWallet = Pick<Keplr, "enable" | "getOfflineSigner" | "signDirect" | "signAmino" | "signArbitrary" | "getKey">;
+declare const getCactusCosmos: () => Wallet;
+
 /**
  * Function to return cosmostation object (which is {@link Wallet}) and throws and error if it does not exist on `window`.
  *
@@ -348,38 +357,38 @@ declare const getLeap: () => Wallet;
 declare const getMetamaskSnapLeap: () => Wallet;
 
 /**
- * Function to return {@link Wallet} object and throws and error if it does not exist on `window`.
+ * Function to return okxwallet object (which is {@link Wallet}) and throws and error if it does not exist on `window`.
  *
  * @example
  * ```ts
  * try {
- *   const vectis = getVectis();
+ *   const okxWallet = getOkx();
  * } catch (error: Error) {
  *   console.error(error.message);
  * }
  * ```
  *
- *
+ * @see https://www.okx.com/web3/build/docs/sdks/chains/cosmos/provider
  */
-declare const getVectis: () => Wallet;
+declare const getOkx: () => Wallet;
+
+declare const getPara: () => Wallet;
 
 /**
- * Function to return okxwallet object (which is {@link Wallet}) and throws and error if it does not exist on `window`.
+ * Function to return {@link Wallet} object and throws and error if it does not exist on `window`.
  *
  * @example
  * ```ts
  * try {
- *   const okxWallet = getOkx();
+ *   const vectis = getVectis();
  * } catch (error: Error) {
  *   console.error(error.message);
  * }
  * ```
  *
- * @see https://www.okx.com/web3/build/docs/sdks/chains/cosmos/provider
+ *
  */
-declare const getOkx: () => Wallet;
-
-declare const getPara: () => Wallet;
+declare const getVectis: () => Wallet;
 
 interface GetWalletConnectParams {
     encoding: BufferEncoding;
@@ -451,20 +460,58 @@ interface MutationEventArgs<TInitial = unknown, TSuccess = TInitial> {
     onLoading?: (data: TInitial) => unknown;
     onSuccess?: (data: TSuccess) => unknown;
 }
-type ChainId = string;
-type UseMultiChainQueryResult<TMulti extends MultiChainHookArgs, TData> = UseQueryResult<TMulti["multiChain"] extends true ? Record<ChainId, TData> : TData>;
+/**
+ * Type utility to convert a readonly array of chain IDs to a mapped record type.
+ * This enables type inference for chainId arrays.
+ *
+ * @example
+ * ```ts
+ * type Result = ChainIdToRecord<readonly ["cosmoshub-4", "osmosis-1"], Key>;
+ * // Result: { "cosmoshub-4": Key, "osmosis-1": Key }
+ * ```
+ */
+type ChainIdToRecord<T extends readonly string[], TData> = {
+    [K in T[number]]: TData;
+};
+/**
+ * Query result type for multi-chain hooks with type inference.
+ *
+ * - When `chainId` is provided as a readonly array, returns a Record with exact keys
+ * - When `chainId` is undefined, returns a generic Record<string, TData>
+ *
+ * @example
+ * ```ts
+ * // Type inference with chainId array
+ * const result: UseMultiChainQueryResult<readonly ["cosmoshub-4"], Key>;
+ * // result.data?: { "cosmoshub-4": Key }
+ *
+ * // Generic type when chainId is undefined
+ * const result: UseMultiChainQueryResult<undefined, Key>;
+ * // result.data?: Record<string, Key>
+ * ```
+ */
+type UseMultiChainQueryResult<TChainIds extends readonly string[] | undefined, TData> = UseQueryResult<TChainIds extends readonly string[] ? ChainIdToRecord<TChainIds, TData> : Record<string, TData>>;
 interface QueryConfig {
     enabled?: boolean;
 }
 
+/**
+ * ChainId is now always an array of chain IDs.
+ * This ensures consistent multi-chain behavior across all hooks.
+ */
+type ChainId = string[];
+
 interface UseAccountArgs {
     onConnect?: (args: ConnectResult & {
         isReconnect: boolean;
     }) => void;
     onDisconnect?: () => void;
 }
-interface UseAccountResult<TMulti extends MultiChainHookArgs> {
-    data?: TMulti["multiChain"] extends true ? Record<string, Key$1 | undefined> : Key$1 | undefined;
+/**
+ * Return type for useAccount hook with type inference based on chainId parameter.
+ */
+interface UseAccountResult<TChainIds extends readonly string[] | undefined> {
+    data?: TChainIds extends readonly string[] ? ChainIdToRecord<TChainIds, Key$1 | undefined> : Record<string, Key$1 | undefined>;
     isConnected: boolean;
     isConnecting: boolean;
     isDisconnected: boolean;
@@ -478,68 +525,87 @@ interface UseAccountResult<TMulti extends MultiChainHookArgs> {
  * graz query hook to retrieve account data with optional arguments to invoke
  * given function on connect/disconnect.
  *
+ * Note: All hooks now return multi-chain results by default (Record<chainId, T>).
+ *
  * @example
  * ```tsx
  * import { useAccount } from "graz";
  *
- * // basic example
- * const { data:account, isConnecting, isConnected, ... } = useAccount();
- * account.bech32Address
- * // multichain example
- * const { data: accounts, isConnecting, isConnected, ... } = useAccount({ chainId: ["cosmoshub-4", "sommelier-3"], multiChain: true });
- * accounts['cosmoshub-4'].bech32Address
- * // with event arguments
+ * // Single chain with precise type inference
+ * const { data: accounts } = useAccount({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": Key } }
+ * const account = accounts?.["cosmoshub-4"];
+ * account?.bech32Address; // ✅ TypeScript knows this exists!
+ *
+ * // Multiple chains with precise type inference
+ * const { data: accounts } = useAccount({
+ *   chainId: ["cosmoshub-4", "osmosis-1"]
+ * });
+ * // Type: { data?: { "cosmoshub-4": Key, "osmosis-1": Key } }
+ * const cosmosAccount = accounts?.["cosmoshub-4"]; // ✅ Autocomplete!
+ * const osmosisAccount = accounts?.["osmosis-1"]; // ✅ Autocomplete!
+ *
+ * // All connected chains (generic Record type)
+ * const { data: accounts } = useAccount();
+ * // Type: { data?: Record<string, Key> }
+ *
+ * // With event callbacks
  * useAccount({
- *   onConnect: ({ account, isReconnect }) => { ... },
+ *   chainId: ["cosmoshub-4"],
+ *   onConnect: ({ accounts, isReconnect }) => { ... },
  *   onDisconnect: () => { ... },
  * });
  * ```
  */
-declare const useAccount: <TMulti extends MultiChainHookArgs>(args?: UseAccountArgs & TMulti) => UseAccountResult<TMulti>;
+declare function useAccount<const TChainIds extends readonly string[]>(args: UseAccountArgs & {
+    chainId: TChainIds;
+}): UseAccountResult<TChainIds>;
+declare function useAccount(args?: UseAccountArgs): UseAccountResult<undefined>;
 /**
- * graz query hook to retrieve list of balances from current account or given address.
+ * graz query hook to retrieve list of balances for a specific chain and address.
  *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
+ * @param chainId - Chain ID to query balances from
+ * @param bech32Address - Required bech32 account address
  *
  * @example
  * ```ts
  * import { useBalances } from "graz";
  *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalances();
- *
- * // multichain example
- * const { data:balances, isFetching, refetch, ... } = useBalances({chainId: ["cosmoshub-4", "sommelier-3"] multiChain: true});
- * const cosmoshubBalances = balances["cosmoshub-4"]
- *
+ * const { data: balances } = useBalances({
+ *   chainId: "cosmoshub-4",
+ *   bech32Address: "cosmos1..."
+ * });
+ * // Type: { data?: Coin[] }
  * ```
  */
-declare const useBalances: <TMulti extends MultiChainHookArgs>(args?: {
-    bech32Address?: string;
-} & TMulti & QueryConfig) => UseMultiChainQueryResult<TMulti, Coin[]>;
+declare const useBalances: (args: {
+    bech32Address: string;
+    chainId: string;
+} & QueryConfig) => UseQueryResult<Coin[], unknown>;
 /**
- * graz query hook to retrieve specific asset balance from current account or given address.
+ * graz query hook to retrieve specific asset balance for a specific chain and address.
  *
+ * @param chainId - Chain ID to query balance from
+ * @param bech32Address - Required bech32 account 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({denom: "atom"});
- *
- * // with custom bech32 address
- * useBalance("atom", "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu");
+ * const { data: balance } = useBalance({
+ *   chainId: "cosmoshub-4",
+ *   bech32Address: "cosmos1...",
+ *   denom: "uatom"
+ * });
+ * // Type: { data?: Coin | undefined }
  * ```
  */
-declare const useBalance: <TMulti extends MultiChainHookArgs>(args: {
-    denom?: string;
-    bech32Address?: string;
-} & {
-    chainId: ChainId$1;
-} & QueryConfig) => UseMultiChainQueryResult<TMulti, Coin | undefined>;
+declare const useBalance: (args: {
+    bech32Address: string;
+    chainId: string;
+    denom: string;
+} & QueryConfig) => UseQueryResult<Coin | undefined, unknown>;
 type UseConnectChainArgs = MutationEventArgs<ConnectArgs, ConnectResult>;
 /**
  * graz mutation hook to execute wallet connection with optional arguments to
@@ -610,10 +676,10 @@ declare const useConnect: ({ onError, onLoading, onSuccess }?: UseConnectChainAr
  */
 declare const useDisconnect: ({ onError, onLoading, onSuccess }?: MutationEventArgs) => {
     disconnect: (args?: {
-        chainId?: ChainId$1;
+        chainId?: ChainId;
     }) => void;
     disconnectAsync: (args?: {
-        chainId?: ChainId$1;
+        chainId?: ChainId;
     }) => Promise<void>;
     error: Error | null;
     isLoading: boolean;
@@ -623,45 +689,59 @@ 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.
+ * Note: Returns multi-chain results by default (Record<chainId, OfflineSigners>).
+ * Signer objects are initialized after connecting an account.
  *
  * @example
  * ```ts
- *
- * // basic example
  * import { useOfflineSigners } from "graz";
- * const { offlineSigner, offlineSignerAmino, offlineSignerAuto } = useOfflineSigners();
  *
- * // multichain example
- * const offlineSigners = useOfflineSigners({chainId: ["cosmoshub-4", "sommelier-3"] multiChain: true});
- * const cosmoshubOfflineSigners = offlineSigners["cosmoshub-4"]
+ * // Single chain with precise type inference
+ * const { data: signers } = useOfflineSigners({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": OfflineSigners } }
+ * const { offlineSigner, offlineSignerAmino, offlineSignerAuto } = signers?.["cosmoshub-4"] || {};
  *
+ * // Multiple chains with precise type inference
+ * const { data: signers } = useOfflineSigners({
+ *   chainId: ["cosmoshub-4", "osmosis-1"]
+ * });
+ * // Type: { data?: { "cosmoshub-4": OfflineSigners, "osmosis-1": OfflineSigners } }
+ * const cosmosSigners = signers?.["cosmoshub-4"]; // ✅ Autocomplete!
+ *
+ * // All connected chains
+ * const { data: signers } = useOfflineSigners();
+ * // Type: { data?: Record<string, OfflineSigners> }
  * ```
  */
-declare const useOfflineSigners: <TMulti extends MultiChainHookArgs>(args?: TMulti) => UseMultiChainQueryResult<TMulti, OfflineSigners>;
+declare function useOfflineSigners<const TChainIds extends readonly string[]>(args: {
+    chainId: TChainIds;
+}): UseMultiChainQueryResult<TChainIds, OfflineSigners>;
+declare function useOfflineSigners(args?: {}): UseMultiChainQueryResult<undefined, OfflineSigners>;
 /**
- * graz query hook to retrieve list of staked balances from current account or given address.
+ * graz query hook to retrieve staked balance for a specific chain and address.
  *
- * @param bech32Address - Optional bech32 account address, defaults to connected account address
+ * @param chainId - Chain ID to query staked balance from
+ * @param bech32Address - Required bech32 account address
  *
  * @example
  * ```ts
- * import { useBalanceStaked } from "graz";
- *
- * // basic example
- * const { data, isFetching, refetch, ... } = useBalanceStaked();
+ * import { useBalanceStaked, useAccount } from "graz";
  *
- * // multichain example
- * const { data:balanceStaked, isFetching, refetch, ... } = useBalanceStaked({chainId: ["cosmoshub-4", "sommelier-3"] multiChain: true});
- * const cosmoshubBalanceStaked = balances["cosmoshub-4"]
+ * const { data: accounts } = useAccount();
+ * const account = accounts?.["cosmoshub-4"];
  *
- * // with custom bech32 address
- * useBalanceStaked({ bech32Address: "cosmos1kpzxx2lxg05xxn8mfygrerhmkj0ypn8edmu2pu"});
+ * const { data: stakedBalance } = useBalanceStaked({
+ *   chainId: "cosmoshub-4",
+ *   bech32Address: account?.bech32Address || "",
+ *   enabled: Boolean(account?.bech32Address),
+ * });
+ * // Type: { data?: Coin }
  * ```
  */
-declare const useBalanceStaked: <TMulti extends MultiChainHookArgs>(args?: {
-    bech32Address?: string;
-} & TMulti) => UseMultiChainQueryResult<TMulti, Coin>;
+declare const useBalanceStaked: (args: {
+    bech32Address: string;
+    chainId: string;
+} & QueryConfig) => UseQueryResult<Coin, unknown>;
 
 /**
  * graz hook to retrieve connected account's active chainIds
@@ -695,23 +775,28 @@ declare const useActiveChains: () => ChainInfo[] | undefined;
  * const chainInfo = useChainInfo({chainId: "cosmoshub-4"});
  * ```
  */
-declare const useChainInfo: ({ chainId }: {
+declare const useChainInfo: ({ chainId }?: {
     chainId?: string;
 }) => ChainInfo | undefined;
 /**
  * graz hook to retrieve ChainInfo objects from GrazProvider with given chainId
  *
- * @param chainId - chainId to search
+ * @param chainId - chainId array to filter. If not provided, returns all chains
  *
  * @example
  * ```ts
  * import { useChainInfos } from "graz";
+ *
+ * // Get specific chains
  * const chainInfos = useChainInfos({chainId: ["cosmoshub-4", "juno-1"]});
+ *
+ * // Get all chains
+ * const allChains = useChainInfos();
  * ```
  */
-declare const useChainInfos: ({ chainId }: {
+declare const useChainInfos: ({ chainId }?: {
     chainId?: string[];
-}) => ChainInfo[] | undefined;
+}) => ChainInfo[] | null | undefined;
 /**
  * graz hook to retrieve specific connected chains currency
  *
@@ -782,6 +867,64 @@ declare const useRecentChains: () => {
     data: ChainInfo[] | undefined;
     clear: () => void;
 };
+type UseAddChainArgs = MutationEventArgs<ChainInfo>;
+/**
+ * graz mutation hook to add chain to the internal store
+ * without suggesting it to the wallet
+ *
+ * @example
+ * ```ts
+ * import { useAddChain } from "graz";
+ * const { addChain, isLoading, isSuccess, ... } = useAddChain();
+ *
+ * addChain({
+ *    chainInfo: {
+ *      rpc: "https://rpc.cosmoshub.strange.love",
+ *      rest: "https://api.cosmoshub.strange.love",
+ *      chainId: "cosmoshub-4",
+ *      chainName: "Cosmos Hub",
+ *      stakeCurrency: {
+ *        coinDenom: "ATOM",
+ *        coinMinimalDenom: "uatom",
+ *        coinDecimals: 6,
+ *      },
+ *      bip44: {
+ *        coinType: 118,
+ *      },
+ *      bech32Config: {
+ *        bech32PrefixAccAddr: "cosmos",
+ *        bech32PrefixAccPub: "cosmospub",
+ *        bech32PrefixValAddr: "cosmosvaloper",
+ *        bech32PrefixValPub: "cosmosvaloperpub",
+ *        bech32PrefixConsAddr: "cosmosvalcons",
+ *        bech32PrefixConsPub: "cosmosvalconspub",
+ *      },
+ *      currencies: [
+ *        {
+ *          coinDenom: "ATOM",
+ *          coinMinimalDenom: "uatom",
+ *          coinDecimals: 6,
+ *        },
+ *      ],
+ *      feeCurrencies: [
+ *        {
+ *          coinDenom: "ATOM",
+ *          coinMinimalDenom: "uatom",
+ *          coinDecimals: 6,
+ *        },
+ *      ],
+ *    }
+ * });
+ * ```
+ */
+declare const useAddChain: ({ onError, onLoading, onSuccess }?: UseAddChainArgs) => {
+    addChain: _tanstack_react_query.UseMutateFunction<ChainInfo, Error, AddChainArgs, unknown>;
+    addChainAsync: _tanstack_react_query.UseMutateAsyncFunction<ChainInfo, Error, AddChainArgs, unknown>;
+    error: Error | null;
+    isLoading: boolean;
+    isSuccess: boolean;
+    status: "error" | "success" | "pending" | "idle";
+};
 type UseSuggestChainArgs = MutationEventArgs<ChainInfo>;
 /**
  * graz mutation hook to suggest chain to a Wallet
@@ -851,96 +994,255 @@ declare const useSuggestChainAndConnect: ({ onError, onLoading, onSuccess }?: Us
 /**
  * graz query hook to retrieve a StargateClient.
  *
+ * Note: Returns multi-chain results by default (Record<chainId, StargateClient>).
+ *
  * @example
  * ```ts
  * import { useStargateClient } from "graz";
  *
- * // single chain
- * const { data:client, isFetching, refetch, ... } = useStargateClient();
- * await client.getAccount("address")
+ * // Single chain with precise type inference
+ * const { data: clients } = useStargateClient({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": StargateClient } }
+ * const client = clients?.["cosmoshub-4"];
+ * await client?.getAccount("address");
  *
- * // multi chain
- * const { data:clients, isFetching, refetch, ... } = useStargateClient({multiChain: true, chainId: ["cosmoshub-4", "sommelier-3"]});
- * await clients["cosmoshub-4"].getAccount("address")
+ * // Multiple chains with precise type inference
+ * const { data: clients } = useStargateClient({
+ *   chainId: ["cosmoshub-4", "osmosis-1"]
+ * });
+ * // Type: { data?: { "cosmoshub-4": StargateClient, "osmosis-1": StargateClient } }
+ * await clients?.["cosmoshub-4"]?.getAccount("address"); // ✅ Autocomplete!
  *
+ * // All connected chains
+ * const { data: clients } = useStargateClient();
+ * // Type: { data?: Record<string, StargateClient> }
  * ```
  */
-declare const useStargateClient: <TMulti extends MultiChainHookArgs>(args?: TMulti & QueryConfig) => UseMultiChainQueryResult<TMulti, StargateClient>;
+declare function useStargateClient<const TChainIds extends readonly string[]>(args: {
+    chainId: TChainIds;
+} & QueryConfig): UseMultiChainQueryResult<TChainIds, StargateClient>;
+declare function useStargateClient(args?: QueryConfig): UseMultiChainQueryResult<undefined, StargateClient>;
 /**
  * graz query hook to retrieve a CosmWasmClient.
  *
+ * Note: Returns multi-chain results by default (Record<chainId, CosmWasmClient>).
+ *
  * @example
  * ```ts
  * import { useCosmWasmClient } from "graz";
  *
- * //single chain
- * const { data:client, isFetching, refetch, ... } = useCosmWasmClient();
- * await client.getAccount("address")
+ * // Single chain with precise type inference
+ * const { data: clients } = useCosmWasmClient({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": CosmWasmClient } }
+ * const client = clients?.["cosmoshub-4"];
+ * await client?.getAccount("address");
  *
- * // multi chain
- * const { data:clients, isFetching, refetch, ... } = useCosmWasmClient({multiChain: true, chainId: ["cosmoshub-4", "sommelier-3"]});
- * await clients["cosmoshub-4"].getAccount("address")
+ * // Multiple chains with precise type inference
+ * const { data: clients } = useCosmWasmClient({
+ *   chainId: ["cosmoshub-4", "osmosis-1"]
+ * });
+ * // Type: { data?: { "cosmoshub-4": CosmWasmClient, "osmosis-1": CosmWasmClient } }
+ * await clients?.["cosmoshub-4"]?.getAccount("address"); // ✅ Autocomplete!
  *
+ * // All connected chains
+ * const { data: clients } = useCosmWasmClient();
+ * // Type: { data?: Record<string, CosmWasmClient> }
  * ```
  */
-declare const useCosmWasmClient: <TMulti extends MultiChainHookArgs>(args?: TMulti & QueryConfig) => UseMultiChainQueryResult<TMulti, CosmWasmClient>;
+declare function useCosmWasmClient<const TChainIds extends readonly string[]>(args: {
+    chainId: TChainIds;
+} & QueryConfig): UseMultiChainQueryResult<TChainIds, CosmWasmClient>;
+declare function useCosmWasmClient(args?: QueryConfig): UseMultiChainQueryResult<undefined, CosmWasmClient>;
 
 /**
- * graz mutation hook to send tokens. Note: if `senderAddress` undefined, it will use current connected account address.
+ * graz mutation hook to send tokens.
  *
  * @example
  * ```ts
- * import { useSendTokens, useStargateSigningClient } from "graz";
+ * import { useSendTokens, useStargateSigningClient, useAccount } from "graz";
+ *
+ * // Get the account and signing client
+ * const { data: accounts } = useAccount({ chainId: ["cosmoshub-4"] });
+ * const { data: signingClients } = useStargateSigningClient({ chainId: ["cosmoshub-4"] });
+ *
+ * const account = accounts?.["cosmoshub-4"];
+ * const signingClient = signingClients?.["cosmoshub-4"];
  *
- * // basic example
- * const { data: signingClient } = useStargateSigningClient()
  * const { sendTokens } = useSendTokens();
  *
  * sendTokens({
  *    signingClient,
- *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430";
- *    amount: [coin];
- *    ...
+ *    senderAddress: account.bech32Address,
+ *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430",
+ *    amount: [coin],
+ *    fee: "auto"
  * })
  * ```
  *
  * @see {@link sendTokens}
  */
 declare const useSendTokens: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SendTokensArgs, DeliverTxResponse>) => {
-    error: Error | null;
-    isLoading: boolean;
-    isSuccess: boolean;
     sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
     sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
-    status: "error" | "success" | "pending" | "idle";
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    data: undefined;
+    variables: SendTokensArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: SendTokensArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    sendTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendTokensArgs, unknown>;
+    data: DeliverTxResponse;
+    error: null;
+    variables: SendTokensArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
 };
 /**
- * graz mutation hook to send IBC tokens. Note: if `senderAddress` undefined, it will use current connected account address.
- *
+ * graz mutation hook to send IBC tokens.
  *
  * @example
  * ```ts
- * import { useSendIbcTokens, useStargateSigningClient } from "graz";
+ * import { useSendIbcTokens, useStargateSigningClient, useAccount } from "graz";
+ *
+ * // Get the account and signing client
+ * const { data: accounts } = useAccount({ chainId: ["cosmoshub-4"] });
+ * const { data: signingClients } = useStargateSigningClient({ chainId: ["cosmoshub-4"] });
+ *
+ * const account = accounts?.["cosmoshub-4"];
+ * const signingClient = signingClients?.["cosmoshub-4"];
  *
- * // basic example
- * const { data: signingClient } = useStargateSigningClient()
  * const { sendIbcTokens } = useSendIbcTokens();
  *
  * sendIbcTokens({
  *    signingClient,
+ *    senderAddress: account.bech32Address,
  *    recipientAddress: "cosmos1g3jjhgkyf36pjhe7u5cw8j9u6cgl8x929ej430",
  *    transferAmount: coin,
- *    ...
+ *    fee: "auto"
  * })
  * ```
  */
 declare const useSendIbcTokens: ({ onError, onLoading, onSuccess, }?: MutationEventArgs<SendIbcTokensArgs, DeliverTxResponse>) => {
-    error: Error | null;
-    isLoading: boolean;
-    isSuccess: boolean;
     sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
     sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
-    status: "error" | "success" | "pending" | "idle";
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    data: undefined;
+    variables: SendIbcTokensArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: SendIbcTokensArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    sendIbcTokens: _tanstack_react_query.UseMutateFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    sendIbcTokensAsync: _tanstack_react_query.UseMutateAsyncFunction<DeliverTxResponse, Error, SendIbcTokensArgs, unknown>;
+    data: DeliverTxResponse;
+    error: null;
+    variables: SendIbcTokensArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
 };
 type UseInstantiateContractArgs<Message extends Record<string, unknown>> = {
     codeId: number;
@@ -950,9 +1252,15 @@ type UseInstantiateContractArgs<Message extends Record<string, unknown>> = {
  *
  * @example
  * ```ts
- * import { useInstantiateContract, useCosmwasmSigningClient } from "graz"
+ * import { useInstantiateContract, useCosmWasmSigningClient, useAccount } from "graz"
+ *
+ * // Get the account and signing client
+ * const { data: accounts } = useAccount({ chainId: ["juno-1"] });
+ * const { data: signingClients } = useCosmWasmSigningClient({ chainId: ["juno-1"] });
+ *
+ * const account = accounts?.["juno-1"];
+ * const signingClient = signingClients?.["juno-1"];
  *
- * const { data: signingClient } = useCosmwasmSigningClient()
  * const { instantiateContract: instantiateMyContract } = useInstantiateContract({
  *   codeId: 4,
  *   onSuccess: ({ contractAddress }) => console.log('Address:', contractAddress)
@@ -961,18 +1269,81 @@ type UseInstantiateContractArgs<Message extends Record<string, unknown>> = {
  * const instantiateMessage = { foo: 'bar' };
  * instantiateMyContract({
  *  signingClient,
- *  msg: instatiateMessage,
- *  label: "test"
+ *  senderAddress: account.bech32Address,
+ *  msg: instantiateMessage,
+ *  label: "test",
+ *  fee: "auto"
  * });
  * ```
  */
 declare const useInstantiateContract: <Message extends Record<string, unknown>>({ codeId, onError, onLoading, onSuccess, }: UseInstantiateContractArgs<Message>) => {
-    error: Error | null;
-    isLoading: boolean;
-    isSuccess: boolean;
     instantiateContract: _tanstack_react_query.UseMutateFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
     instantiateContractAsync: _tanstack_react_query.UseMutateAsyncFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
-    status: "error" | "success" | "pending" | "idle";
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    instantiateContract: _tanstack_react_query.UseMutateFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    instantiateContractAsync: _tanstack_react_query.UseMutateAsyncFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    data: undefined;
+    variables: InstantiateContractMutationArgs<Message>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    instantiateContract: _tanstack_react_query.UseMutateFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    instantiateContractAsync: _tanstack_react_query.UseMutateAsyncFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    data: undefined;
+    error: Error;
+    variables: InstantiateContractMutationArgs<Message>;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    instantiateContract: _tanstack_react_query.UseMutateFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    instantiateContractAsync: _tanstack_react_query.UseMutateAsyncFunction<InstantiateResult, Error, InstantiateContractMutationArgs<Message>, unknown>;
+    data: InstantiateResult;
+    error: null;
+    variables: InstantiateContractMutationArgs<Message>;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
 };
 type UseExecuteContractArgs<Message extends Record<string, unknown>> = {
     contractAddress: string;
@@ -983,37 +1354,103 @@ type UseExecuteContractArgs<Message extends Record<string, unknown>> = {
  *
  * @example
  * ```ts
- * import { useExecuteContract, useCosmWasmSigningClient } from "graz"
+ * import { useExecuteContract, useCosmWasmSigningClient, useAccount } from "graz"
  *
- * interface GreetMessage {
- *   name: string;
+ * interface ExecuteMessage {
+ *   foo: string;
  * }
  *
- * interface GreetResponse {
- *   message: string;
- * }
+ * const contractAddress = "juno1...";
+ *
+ * // Get the account and signing client
+ * const { data: accounts } = useAccount({ chainId: ["juno-1"] });
+ * const { data: signingClients } = useCosmWasmSigningClient({ chainId: ["juno-1"] });
  *
- * const contractAddress = "cosmosfoobarbaz";
+ * const account = accounts?.["juno-1"];
+ * const signingClient = signingClients?.["juno-1"];
  *
- * const { data: signingClient } = useCosmWasmSigningClient()
- * const { executeContract } = useExecuteContract<ExecuteMessage>({ contractAddress });
+ * const { executeContract } = useExecuteContract<ExecuteMessage>({
+ *   contractAddress,
+ *   onSuccess: (result) => console.log('Tx hash:', result.transactionHash)
+ * });
  *
  * executeContract({
  *  signingClient,
- *  msg: {
- *    foo: "bar"
- *  }}, {
- *    onSuccess: (data: GreetResponse) => console.log('Got message:', data.message);
- *  });
+ *  senderAddress: account.bech32Address,
+ *  msg: { foo: "bar" },
+ *  fee: "auto",
+ *  funds: []
+ * });
  * ```
  */
 declare const useExecuteContract: <Message extends Record<string, unknown>>({ contractAddress, onError, onLoading, onSuccess, }: UseExecuteContractArgs<Message>) => {
-    error: Error | null;
-    isLoading: boolean;
-    isSuccess: boolean;
     executeContract: _tanstack_react_query.UseMutateFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
     executeContractAsync: _tanstack_react_query.UseMutateAsyncFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
-    status: "error" | "success" | "pending" | "idle";
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    executeContract: _tanstack_react_query.UseMutateFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    executeContractAsync: _tanstack_react_query.UseMutateAsyncFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    data: undefined;
+    variables: ExecuteContractMutationArgs<Message>;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    executeContract: _tanstack_react_query.UseMutateFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    executeContractAsync: _tanstack_react_query.UseMutateAsyncFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    data: undefined;
+    error: Error;
+    variables: ExecuteContractMutationArgs<Message>;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    executeContract: _tanstack_react_query.UseMutateFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    executeContractAsync: _tanstack_react_query.UseMutateAsyncFunction<ExecuteResult, Error, ExecuteContractMutationArgs<Message>, unknown>;
+    data: ExecuteResult;
+    error: null;
+    variables: ExecuteContractMutationArgs<Message>;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
 };
 /**
  * graz query hook for dispatching a "smart" query to a CosmWasm smart
@@ -1039,22 +1476,85 @@ declare const useQueryRaw: <TError>(args?: {
     key?: string;
 }) => UseQueryResult<Uint8Array | null, TError>;
 
-interface SiginingClientSinglechainArgs<T> {
-    multiChain?: false;
-    opts?: T;
-}
-interface SiginingClientMultichainArgs<T> {
-    multiChain?: true;
-    opts?: Record<string, T>;
-}
+/**
+ * Base signing client args - now always uses per-chain opts
+ */
 interface BaseSigningClientArgs extends QueryConfig {
-    chainId?: ChainId$1;
     offlineSigner?: "offlineSigner" | "offlineSignerAuto" | "offlineSignerOnlyAmino";
+    opts?: Record<string, SigningStargateClientOptions | SigningCosmWasmClientOptions>;
 }
-declare function useStargateSigningClient(args?: BaseSigningClientArgs & SiginingClientSinglechainArgs<SigningStargateClientOptions>): UseQueryResult<SigningStargateClient | null>;
-declare function useStargateSigningClient(args?: BaseSigningClientArgs & SiginingClientMultichainArgs<SigningStargateClientOptions>): UseQueryResult<Record<string, SigningStargateClient | null>>;
-declare function useCosmWasmSigningClient(args?: BaseSigningClientArgs & SiginingClientSinglechainArgs<SigningCosmWasmClientOptions>): UseQueryResult<SigningCosmWasmClient | null>;
-declare function useCosmWasmSigningClient(args?: BaseSigningClientArgs & SiginingClientMultichainArgs<SigningCosmWasmClientOptions>): UseQueryResult<Record<string, SigningCosmWasmClient | null>>;
+/**
+ * graz query hook to retrieve a SigningStargateClient.
+ *
+ * Note: Returns multi-chain results by default (Record<chainId, SigningStargateClient | null>).
+ * Options are now always per-chain using `opts` Record.
+ *
+ * @example
+ * ```ts
+ * import { useStargateSigningClient } from "graz";
+ *
+ * // Single chain with precise type inference
+ * const { data: clients } = useStargateSigningClient({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": SigningStargateClient | null } }
+ * const client = clients?.["cosmoshub-4"];
+ * await client?.getAccount("address");
+ *
+ * // Multiple chains with per-chain options
+ * const { data: clients } = useStargateSigningClient({
+ *   chainId: ["cosmoshub-4", "osmosis-1"],
+ *   opts: {
+ *     "cosmoshub-4": { gasPrice: GasPrice.fromString("0.025uatom") },
+ *     "osmosis-1": { gasPrice: GasPrice.fromString("0.025uosmo") }
+ *   }
+ * });
+ * // Type: { data?: { "cosmoshub-4": SigningStargateClient | null, "osmosis-1": SigningStargateClient | null } }
+ * await clients?.["cosmoshub-4"]?.getAccount("address"); // ✅ Autocomplete!
+ *
+ * // All connected chains
+ * const { data: clients } = useStargateSigningClient();
+ * // Type: { data?: Record<string, SigningStargateClient | null> }
+ * ```
+ */
+declare function useStargateSigningClient<const TChainIds extends readonly string[]>(args: {
+    chainId: TChainIds;
+} & BaseSigningClientArgs): UseMultiChainQueryResult<TChainIds, SigningStargateClient | null>;
+declare function useStargateSigningClient(args?: BaseSigningClientArgs): UseMultiChainQueryResult<undefined, SigningStargateClient | null>;
+/**
+ * graz query hook to retrieve a SigningCosmWasmClient.
+ *
+ * Note: Returns multi-chain results by default (Record<chainId, SigningCosmWasmClient | null>).
+ * Options are now always per-chain using `opts` Record.
+ *
+ * @example
+ * ```ts
+ * import { useCosmWasmSigningClient } from "graz";
+ *
+ * // Single chain with precise type inference
+ * const { data: clients } = useCosmWasmSigningClient({ chainId: ["cosmoshub-4"] });
+ * // Type: { data?: { "cosmoshub-4": SigningCosmWasmClient | null } }
+ * const client = clients?.["cosmoshub-4"];
+ * await client?.getAccount("address");
+ *
+ * // Multiple chains with per-chain options
+ * const { data: clients } = useCosmWasmSigningClient({
+ *   chainId: ["cosmoshub-4", "osmosis-1"],
+ *   opts: {
+ *     "cosmoshub-4": { gasPrice: GasPrice.fromString("0.025uatom") },
+ *     "osmosis-1": { gasPrice: GasPrice.fromString("0.025uosmo") }
+ *   }
+ * });
+ * // Type: { data?: { "cosmoshub-4": SigningCosmWasmClient | null, "osmosis-1": SigningCosmWasmClient | null } }
+ * await clients?.["cosmoshub-4"]?.getAccount("address"); // ✅ Autocomplete!
+ *
+ * // All connected chains
+ * const { data: clients } = useCosmWasmSigningClient();
+ * // Type: { data?: Record<string, SigningCosmWasmClient | null> }
+ * ```
+ */
+declare function useCosmWasmSigningClient<const TChainIds extends readonly string[]>(args: {
+    chainId: TChainIds;
+} & BaseSigningClientArgs): UseMultiChainQueryResult<TChainIds, SigningCosmWasmClient | null>;
+declare function useCosmWasmSigningClient(args?: BaseSigningClientArgs): UseMultiChainQueryResult<undefined, SigningCosmWasmClient | null>;
 
 /**
  * graz hook to retrieve current active {@link WalletType}
@@ -1130,4 +1630,4 @@ declare const useGrazEvents: () => null;
  */
 declare const GrazEvents: FC;
 
-export { type ConfigureGrazArgs, type ConnectArgs, type ConnectResult, type Dictionary, type ExecuteContractArgs, type ExecuteContractMutationArgs, GrazEvents, GrazProvider, type GrazProviderProps, type InstantiateContractArgs, type InstantiateContractMutationArgs, type Key, type KnownKeys, type Maybe, type OfflineSigners, type ReconnectArgs, type SendIbcTokensArgs, type SendTokensArgs, type SignAminoParams, type SignDirectParams, type SignDoc, type SuggestChainAndConnectArgs, type SuggestChainArgs, type UseAccountArgs, type UseAccountResult, type UseConnectChainArgs, type UseExecuteContractArgs, type UseInstantiateContractArgs, type UseSuggestChainAndConnectArgs, type UseSuggestChainArgs, WALLET_TYPES, type Wallet, WalletType, checkWallet, clearRecentChain, clearSession, configureGraz, connect, defineChainInfo, defineChains, disconnect, executeContract, getAvailableWallets, getChainInfo, getChainInfos, getCosmostation, getKeplr, getLeap, getMetamaskSnapLeap, getOfflineSigners, getOkx, getPara, getQueryRaw, getQuerySmart, getRecentChainIds, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, instantiateContract, isLeapDappBrowser, isLeapSnaps, isPara, isWalletConnect, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, useAccount, useActiveChainCurrency, useActiveChainIds, useActiveChains, useActiveWalletType, useBalance, useBalanceStaked, useBalances, useChainInfo, useChainInfos, useCheckWallet, useConnect, useCosmWasmClient, useCosmWasmSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryClientValidators, useQueryRaw, useQuerySmart, useRecentChainIds, useRecentChains, useSendIbcTokens, useSendTokens, useStargateClient, useStargateSigningClient, useSuggestChain, useSuggestChainAndConnect };
+export { type ActionChainId, type AddChainArgs, type CactusCosmosWallet, type ConfigureGrazArgs, type ConnectArgs, type ConnectResult, type Dictionary, type ExecuteContractArgs, type ExecuteContractMutationArgs, GrazEvents, GrazProvider, type GrazProviderProps, type InstantiateContractArgs, type InstantiateContractMutationArgs, type Key, type KnownKeys, type Maybe, type OfflineSigners, type ReconnectArgs, type SendIbcTokensArgs, type SendTokensArgs, type SignAminoParams, type SignDirectParams, type SignDoc, type SuggestChainAndConnectArgs, type SuggestChainArgs, type UseAccountArgs, type UseAccountResult, type UseAddChainArgs, type UseConnectChainArgs, type UseExecuteContractArgs, type UseInstantiateContractArgs, type UseSuggestChainAndConnectArgs, type UseSuggestChainArgs, WALLET_TYPES, type Wallet, WalletType, addChain, checkWallet, clearRecentChain, clearSession, configureGraz, connect, defineChainInfo, defineChains, disconnect, executeContract, getAvailableWallets, getCactusCosmos, getChainInfo, getChainInfos, getCosmostation, getKeplr, getLeap, getMetamaskSnapLeap, getOfflineSigners, getOkx, getPara, getQueryRaw, getQuerySmart, getRecentChainIds, getRecentChains, getVectis, getWCCosmostation, getWCKeplr, getWCLeap, getWallet, getWalletConnect, instantiateContract, isLeapDappBrowser, isLeapSnaps, isPara, isWalletConnect, reconnect, sendIbcTokens, sendTokens, suggestChain, suggestChainAndConnect, useAccount, useActiveChainCurrency, useActiveChainIds, useActiveChains, useActiveWalletType, useAddChain, useBalance, useBalanceStaked, useBalances, useChainInfo, useChainInfos, useCheckWallet, useConnect, useCosmWasmClient, useCosmWasmSigningClient, useDisconnect, useExecuteContract, useGrazEvents, useInstantiateContract, useOfflineSigners, useQueryClientValidators, useQueryRaw, useQuerySmart, useRecentChainIds, useRecentChains, useSendIbcTokens, useSendTokens, useStargateClient, useStargateSigningClient, useSuggestChain, useSuggestChainAndConnect };