diff --git a/libs/interchainjs/src/cosmos/auth/v1beta1/query.rpc.func.ts b/libs/interchainjs/src/cosmos/auth/v1beta1/query.rpc.func.ts
index 53157bf4..95670acf 100644
--- a/libs/interchainjs/src/cosmos/auth/v1beta1/query.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/auth/v1beta1/query.rpc.func.ts
@@ -1,111 +1,111 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryAccountAddressByIDRequest, QueryAccountAddressByIDResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse, QueryAccountInfoRequest, QueryAccountInfoResponse } from "./query";
-export const createGetAccounts = (getRpcInstance: RpcResolver) => buildQuery<QueryAccountsRequest, QueryAccountsResponse>({
+export const createGetAccounts = (clientResolver: RpcResolver) => buildQuery<QueryAccountsRequest, QueryAccountsResponse>({
   encode: QueryAccountsRequest.encode,
   decode: QueryAccountsResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "Accounts",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccounts = buildUseQuery<QueryAccountsRequest, QueryAccountsResponse>({
   builderQueryFn: createGetAccounts,
   queryKeyPrefix: "AccountsQuery"
 });
-export const createGetAccount = (getRpcInstance: RpcResolver) => buildQuery<QueryAccountRequest, QueryAccountResponse>({
+export const createGetAccount = (clientResolver: RpcResolver) => buildQuery<QueryAccountRequest, QueryAccountResponse>({
   encode: QueryAccountRequest.encode,
   decode: QueryAccountResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "Account",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccount = buildUseQuery<QueryAccountRequest, QueryAccountResponse>({
   builderQueryFn: createGetAccount,
   queryKeyPrefix: "AccountQuery"
 });
-export const createGetAccountAddressByID = (getRpcInstance: RpcResolver) => buildQuery<QueryAccountAddressByIDRequest, QueryAccountAddressByIDResponse>({
+export const createGetAccountAddressByID = (clientResolver: RpcResolver) => buildQuery<QueryAccountAddressByIDRequest, QueryAccountAddressByIDResponse>({
   encode: QueryAccountAddressByIDRequest.encode,
   decode: QueryAccountAddressByIDResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "AccountAddressByID",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountAddressByID = buildUseQuery<QueryAccountAddressByIDRequest, QueryAccountAddressByIDResponse>({
   builderQueryFn: createGetAccountAddressByID,
   queryKeyPrefix: "AccountAddressByIDQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetModuleAccounts = (getRpcInstance: RpcResolver) => buildQuery<QueryModuleAccountsRequest, QueryModuleAccountsResponse>({
+export const createGetModuleAccounts = (clientResolver: RpcResolver) => buildQuery<QueryModuleAccountsRequest, QueryModuleAccountsResponse>({
   encode: QueryModuleAccountsRequest.encode,
   decode: QueryModuleAccountsResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "ModuleAccounts",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleAccounts = buildUseQuery<QueryModuleAccountsRequest, QueryModuleAccountsResponse>({
   builderQueryFn: createGetModuleAccounts,
   queryKeyPrefix: "ModuleAccountsQuery"
 });
-export const createGetModuleAccountByName = (getRpcInstance: RpcResolver) => buildQuery<QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse>({
+export const createGetModuleAccountByName = (clientResolver: RpcResolver) => buildQuery<QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse>({
   encode: QueryModuleAccountByNameRequest.encode,
   decode: QueryModuleAccountByNameResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "ModuleAccountByName",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleAccountByName = buildUseQuery<QueryModuleAccountByNameRequest, QueryModuleAccountByNameResponse>({
   builderQueryFn: createGetModuleAccountByName,
   queryKeyPrefix: "ModuleAccountByNameQuery"
 });
-export const createGetBech32Prefix = (getRpcInstance: RpcResolver) => buildQuery<Bech32PrefixRequest, Bech32PrefixResponse>({
+export const createGetBech32Prefix = (clientResolver: RpcResolver) => buildQuery<Bech32PrefixRequest, Bech32PrefixResponse>({
   encode: Bech32PrefixRequest.encode,
   decode: Bech32PrefixResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "Bech32Prefix",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBech32Prefix = buildUseQuery<Bech32PrefixRequest, Bech32PrefixResponse>({
   builderQueryFn: createGetBech32Prefix,
   queryKeyPrefix: "Bech32PrefixQuery"
 });
-export const createGetAddressBytesToString = (getRpcInstance: RpcResolver) => buildQuery<AddressBytesToStringRequest, AddressBytesToStringResponse>({
+export const createGetAddressBytesToString = (clientResolver: RpcResolver) => buildQuery<AddressBytesToStringRequest, AddressBytesToStringResponse>({
   encode: AddressBytesToStringRequest.encode,
   decode: AddressBytesToStringResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "AddressBytesToString",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAddressBytesToString = buildUseQuery<AddressBytesToStringRequest, AddressBytesToStringResponse>({
   builderQueryFn: createGetAddressBytesToString,
   queryKeyPrefix: "AddressBytesToStringQuery"
 });
-export const createGetAddressStringToBytes = (getRpcInstance: RpcResolver) => buildQuery<AddressStringToBytesRequest, AddressStringToBytesResponse>({
+export const createGetAddressStringToBytes = (clientResolver: RpcResolver) => buildQuery<AddressStringToBytesRequest, AddressStringToBytesResponse>({
   encode: AddressStringToBytesRequest.encode,
   decode: AddressStringToBytesResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "AddressStringToBytes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAddressStringToBytes = buildUseQuery<AddressStringToBytesRequest, AddressStringToBytesResponse>({
   builderQueryFn: createGetAddressStringToBytes,
   queryKeyPrefix: "AddressStringToBytesQuery"
 });
-export const createGetAccountInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryAccountInfoRequest, QueryAccountInfoResponse>({
+export const createGetAccountInfo = (clientResolver: RpcResolver) => buildQuery<QueryAccountInfoRequest, QueryAccountInfoResponse>({
   encode: QueryAccountInfoRequest.encode,
   decode: QueryAccountInfoResponse.decode,
   service: "cosmos.auth.v1beta1.Query",
   method: "AccountInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountInfo = buildUseQuery<QueryAccountInfoRequest, QueryAccountInfoResponse>({
   builderQueryFn: createGetAccountInfo,
diff --git a/libs/interchainjs/src/cosmos/authz/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/authz/v1beta1/tx.rpc.func.ts
index 878d0226..29a22be2 100644
--- a/libs/interchainjs/src/cosmos/authz/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/authz/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
-export const createGrant = (getSigningClient: SigningClientResolver) => buildTx<MsgGrant>({
-  getSigningClient: getSigningClient,
+export const createGrant = (clientResolver: SigningClientResolver) => buildTx<MsgGrant>({
+  clientResolver,
   typeUrl: MsgGrant.typeUrl,
   encoders: toEncoders(MsgGrant),
   converters: toConverters(MsgGrant)
@@ -11,8 +11,8 @@ export const createGrant = (getSigningClient: SigningClientResolver) => buildTx<
 export const useGrant = buildUseMutation<MsgGrant, Error>({
   builderMutationFn: createGrant
 });
-export const createExec = (getSigningClient: SigningClientResolver) => buildTx<MsgExec>({
-  getSigningClient: getSigningClient,
+export const createExec = (clientResolver: SigningClientResolver) => buildTx<MsgExec>({
+  clientResolver,
   typeUrl: MsgExec.typeUrl,
   encoders: toEncoders(MsgExec),
   converters: toConverters(MsgExec)
@@ -20,8 +20,8 @@ export const createExec = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useExec = buildUseMutation<MsgExec, Error>({
   builderMutationFn: createExec
 });
-export const createRevoke = (getSigningClient: SigningClientResolver) => buildTx<MsgRevoke>({
-  getSigningClient: getSigningClient,
+export const createRevoke = (clientResolver: SigningClientResolver) => buildTx<MsgRevoke>({
+  clientResolver,
   typeUrl: MsgRevoke.typeUrl,
   encoders: toEncoders(MsgRevoke),
   converters: toConverters(MsgRevoke)
diff --git a/libs/interchainjs/src/cosmos/bank/v1beta1/query.rpc.func.ts b/libs/interchainjs/src/cosmos/bank/v1beta1/query.rpc.func.ts
index 443fa40f..6649c472 100644
--- a/libs/interchainjs/src/cosmos/bank/v1beta1/query.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/bank/v1beta1/query.rpc.func.ts
@@ -1,144 +1,144 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse, QueryDenomOwnersRequest, QueryDenomOwnersResponse, QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse, QuerySendEnabledRequest, QuerySendEnabledResponse } from "./query";
-export const createGetBalance = (getRpcInstance: RpcResolver) => buildQuery<QueryBalanceRequest, QueryBalanceResponse>({
+export const createGetBalance = (clientResolver: RpcResolver) => buildQuery<QueryBalanceRequest, QueryBalanceResponse>({
   encode: QueryBalanceRequest.encode,
   decode: QueryBalanceResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "Balance",
-  getRpcInstance: getRpcInstance
+  clientResolver: clientResolver
 });
 export const useGetBalance = buildUseQuery<QueryBalanceRequest, QueryBalanceResponse>({
   builderQueryFn: createGetBalance,
   queryKeyPrefix: "BalanceQuery"
 });
-export const createGetAllBalances = (getRpcInstance: RpcResolver) => buildQuery<QueryAllBalancesRequest, QueryAllBalancesResponse>({
+export const createGetAllBalances = (clientResolver: RpcResolver) => buildQuery<QueryAllBalancesRequest, QueryAllBalancesResponse>({
   encode: QueryAllBalancesRequest.encode,
   decode: QueryAllBalancesResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "AllBalances",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllBalances = buildUseQuery<QueryAllBalancesRequest, QueryAllBalancesResponse>({
   builderQueryFn: createGetAllBalances,
   queryKeyPrefix: "AllBalancesQuery"
 });
-export const createGetSpendableBalances = (getRpcInstance: RpcResolver) => buildQuery<QuerySpendableBalancesRequest, QuerySpendableBalancesResponse>({
+export const createGetSpendableBalances = (clientResolver: RpcResolver) => buildQuery<QuerySpendableBalancesRequest, QuerySpendableBalancesResponse>({
   encode: QuerySpendableBalancesRequest.encode,
   decode: QuerySpendableBalancesResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SpendableBalances",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSpendableBalances = buildUseQuery<QuerySpendableBalancesRequest, QuerySpendableBalancesResponse>({
   builderQueryFn: createGetSpendableBalances,
   queryKeyPrefix: "SpendableBalancesQuery"
 });
-export const createGetSpendableBalanceByDenom = (getRpcInstance: RpcResolver) => buildQuery<QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse>({
+export const createGetSpendableBalanceByDenom = (clientResolver: RpcResolver) => buildQuery<QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse>({
   encode: QuerySpendableBalanceByDenomRequest.encode,
   decode: QuerySpendableBalanceByDenomResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SpendableBalanceByDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSpendableBalanceByDenom = buildUseQuery<QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponse>({
   builderQueryFn: createGetSpendableBalanceByDenom,
   queryKeyPrefix: "SpendableBalanceByDenomQuery"
 });
-export const createGetTotalSupply = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalSupplyRequest, QueryTotalSupplyResponse>({
+export const createGetTotalSupply = (clientResolver: RpcResolver) => buildQuery<QueryTotalSupplyRequest, QueryTotalSupplyResponse>({
   encode: QueryTotalSupplyRequest.encode,
   decode: QueryTotalSupplyResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "TotalSupply",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalSupply = buildUseQuery<QueryTotalSupplyRequest, QueryTotalSupplyResponse>({
   builderQueryFn: createGetTotalSupply,
   queryKeyPrefix: "TotalSupplyQuery"
 });
-export const createGetSupplyOf = (getRpcInstance: RpcResolver) => buildQuery<QuerySupplyOfRequest, QuerySupplyOfResponse>({
+export const createGetSupplyOf = (clientResolver: RpcResolver) => buildQuery<QuerySupplyOfRequest, QuerySupplyOfResponse>({
   encode: QuerySupplyOfRequest.encode,
   decode: QuerySupplyOfResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SupplyOf",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSupplyOf = buildUseQuery<QuerySupplyOfRequest, QuerySupplyOfResponse>({
   builderQueryFn: createGetSupplyOf,
   queryKeyPrefix: "SupplyOfQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetDenomMetadata = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomMetadataRequest, QueryDenomMetadataResponse>({
+export const createGetDenomMetadata = (clientResolver: RpcResolver) => buildQuery<QueryDenomMetadataRequest, QueryDenomMetadataResponse>({
   encode: QueryDenomMetadataRequest.encode,
   decode: QueryDenomMetadataResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomMetadata",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomMetadata = buildUseQuery<QueryDenomMetadataRequest, QueryDenomMetadataResponse>({
   builderQueryFn: createGetDenomMetadata,
   queryKeyPrefix: "DenomMetadataQuery"
 });
-export const createGetDenomMetadataByQueryString = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse>({
+export const createGetDenomMetadataByQueryString = (clientResolver: RpcResolver) => buildQuery<QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse>({
   encode: QueryDenomMetadataByQueryStringRequest.encode,
   decode: QueryDenomMetadataByQueryStringResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomMetadataByQueryString",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomMetadataByQueryString = buildUseQuery<QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponse>({
   builderQueryFn: createGetDenomMetadataByQueryString,
   queryKeyPrefix: "DenomMetadataByQueryStringQuery"
 });
-export const createGetDenomsMetadata = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomsMetadataRequest, QueryDenomsMetadataResponse>({
+export const createGetDenomsMetadata = (clientResolver: RpcResolver) => buildQuery<QueryDenomsMetadataRequest, QueryDenomsMetadataResponse>({
   encode: QueryDenomsMetadataRequest.encode,
   decode: QueryDenomsMetadataResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomsMetadata",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomsMetadata = buildUseQuery<QueryDenomsMetadataRequest, QueryDenomsMetadataResponse>({
   builderQueryFn: createGetDenomsMetadata,
   queryKeyPrefix: "DenomsMetadataQuery"
 });
-export const createGetDenomOwners = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomOwnersRequest, QueryDenomOwnersResponse>({
+export const createGetDenomOwners = (clientResolver: RpcResolver) => buildQuery<QueryDenomOwnersRequest, QueryDenomOwnersResponse>({
   encode: QueryDenomOwnersRequest.encode,
   decode: QueryDenomOwnersResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomOwners",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomOwners = buildUseQuery<QueryDenomOwnersRequest, QueryDenomOwnersResponse>({
   builderQueryFn: createGetDenomOwners,
   queryKeyPrefix: "DenomOwnersQuery"
 });
-export const createGetDenomOwnersByQuery = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse>({
+export const createGetDenomOwnersByQuery = (clientResolver: RpcResolver) => buildQuery<QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse>({
   encode: QueryDenomOwnersByQueryRequest.encode,
   decode: QueryDenomOwnersByQueryResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "DenomOwnersByQuery",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomOwnersByQuery = buildUseQuery<QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponse>({
   builderQueryFn: createGetDenomOwnersByQuery,
   queryKeyPrefix: "DenomOwnersByQueryQuery"
 });
-export const createGetSendEnabled = (getRpcInstance: RpcResolver) => buildQuery<QuerySendEnabledRequest, QuerySendEnabledResponse>({
+export const createGetSendEnabled = (clientResolver: RpcResolver) => buildQuery<QuerySendEnabledRequest, QuerySendEnabledResponse>({
   encode: QuerySendEnabledRequest.encode,
   decode: QuerySendEnabledResponse.decode,
   service: "cosmos.bank.v1beta1.Query",
   method: "SendEnabled",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSendEnabled = buildUseQuery<QuerySendEnabledRequest, QuerySendEnabledResponse>({
   builderQueryFn: createGetSendEnabled,
diff --git a/libs/interchainjs/src/cosmos/bank/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/bank/v1beta1/tx.rpc.func.ts
index 70a6a146..b5c63643 100644
--- a/libs/interchainjs/src/cosmos/bank/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/bank/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSend, MsgMultiSend, MsgUpdateParams, MsgSetSendEnabled } from "./tx";
-export const createSend = (getSigningClient: SigningClientResolver) => buildTx<MsgSend>({
-  getSigningClient: getSigningClient,
+export const createSend = (clientResolver: SigningClientResolver) => buildTx<MsgSend>({
+  clientResolver: clientResolver,
   typeUrl: MsgSend.typeUrl,
   encoders: toEncoders(MsgSend),
   converters: toConverters(MsgSend)
@@ -11,8 +11,8 @@ export const createSend = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useSend = buildUseMutation<MsgSend, Error>({
   builderMutationFn: createSend
 });
-export const createMultiSend = (getSigningClient: SigningClientResolver) => buildTx<MsgMultiSend>({
-  getSigningClient: getSigningClient,
+export const createMultiSend = (clientResolver: SigningClientResolver) => buildTx<MsgMultiSend>({
+  clientResolver,
   typeUrl: MsgMultiSend.typeUrl,
   encoders: toEncoders(MsgMultiSend),
   converters: toConverters(MsgMultiSend)
@@ -20,8 +20,8 @@ export const createMultiSend = (getSigningClient: SigningClientResolver) => buil
 export const useMultiSend = buildUseMutation<MsgMultiSend, Error>({
   builderMutationFn: createMultiSend
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
@@ -29,8 +29,8 @@ export const createUpdateParams = (getSigningClient: SigningClientResolver) => b
 export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
   builderMutationFn: createUpdateParams
 });
-export const createSetSendEnabled = (getSigningClient: SigningClientResolver) => buildTx<MsgSetSendEnabled>({
-  getSigningClient: getSigningClient,
+export const createSetSendEnabled = (clientResolver: SigningClientResolver) => buildTx<MsgSetSendEnabled>({
+  clientResolver,
   typeUrl: MsgSetSendEnabled.typeUrl,
   encoders: toEncoders(MsgSetSendEnabled),
   converters: toConverters(MsgSetSendEnabled)
diff --git a/libs/interchainjs/src/cosmos/distribution/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/distribution/v1beta1/tx.rpc.func.ts
index bc099f0b..0a2718cd 100644
--- a/libs/interchainjs/src/cosmos/distribution/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/distribution/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSetWithdrawAddress, MsgWithdrawDelegatorReward, MsgWithdrawValidatorCommission, MsgFundCommunityPool, MsgUpdateParams, MsgCommunityPoolSpend, MsgDepositValidatorRewardsPool } from "./tx";
-export const createSetWithdrawAddress = (getSigningClient: SigningClientResolver) => buildTx<MsgSetWithdrawAddress>({
-  getSigningClient: getSigningClient,
+export const createSetWithdrawAddress = (clientResolver: SigningClientResolver) => buildTx<MsgSetWithdrawAddress>({
+  clientResolver,
   typeUrl: MsgSetWithdrawAddress.typeUrl,
   encoders: toEncoders(MsgSetWithdrawAddress),
   converters: toConverters(MsgSetWithdrawAddress)
@@ -11,8 +11,8 @@ export const createSetWithdrawAddress = (getSigningClient: SigningClientResolver
 export const useSetWithdrawAddress = buildUseMutation<MsgSetWithdrawAddress, Error>({
   builderMutationFn: createSetWithdrawAddress
 });
-export const createWithdrawDelegatorReward = (getSigningClient: SigningClientResolver) => buildTx<MsgWithdrawDelegatorReward>({
-  getSigningClient: getSigningClient,
+export const createWithdrawDelegatorReward = (clientResolver: SigningClientResolver) => buildTx<MsgWithdrawDelegatorReward>({
+  clientResolver,
   typeUrl: MsgWithdrawDelegatorReward.typeUrl,
   encoders: toEncoders(MsgWithdrawDelegatorReward),
   converters: toConverters(MsgWithdrawDelegatorReward)
@@ -20,8 +20,8 @@ export const createWithdrawDelegatorReward = (getSigningClient: SigningClientRes
 export const useWithdrawDelegatorReward = buildUseMutation<MsgWithdrawDelegatorReward, Error>({
   builderMutationFn: createWithdrawDelegatorReward
 });
-export const createWithdrawValidatorCommission = (getSigningClient: SigningClientResolver) => buildTx<MsgWithdrawValidatorCommission>({
-  getSigningClient: getSigningClient,
+export const createWithdrawValidatorCommission = (clientResolver: SigningClientResolver) => buildTx<MsgWithdrawValidatorCommission>({
+  clientResolver,
   typeUrl: MsgWithdrawValidatorCommission.typeUrl,
   encoders: toEncoders(MsgWithdrawValidatorCommission),
   converters: toConverters(MsgWithdrawValidatorCommission)
@@ -29,8 +29,8 @@ export const createWithdrawValidatorCommission = (getSigningClient: SigningClien
 export const useWithdrawValidatorCommission = buildUseMutation<MsgWithdrawValidatorCommission, Error>({
   builderMutationFn: createWithdrawValidatorCommission
 });
-export const createFundCommunityPool = (getSigningClient: SigningClientResolver) => buildTx<MsgFundCommunityPool>({
-  getSigningClient: getSigningClient,
+export const createFundCommunityPool = (clientResolver: SigningClientResolver) => buildTx<MsgFundCommunityPool>({
+  clientResolver,
   typeUrl: MsgFundCommunityPool.typeUrl,
   encoders: toEncoders(MsgFundCommunityPool),
   converters: toConverters(MsgFundCommunityPool)
@@ -38,8 +38,8 @@ export const createFundCommunityPool = (getSigningClient: SigningClientResolver)
 export const useFundCommunityPool = buildUseMutation<MsgFundCommunityPool, Error>({
   builderMutationFn: createFundCommunityPool
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
@@ -47,8 +47,8 @@ export const createUpdateParams = (getSigningClient: SigningClientResolver) => b
 export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
   builderMutationFn: createUpdateParams
 });
-export const createCommunityPoolSpend = (getSigningClient: SigningClientResolver) => buildTx<MsgCommunityPoolSpend>({
-  getSigningClient: getSigningClient,
+export const createCommunityPoolSpend = (clientResolver: SigningClientResolver) => buildTx<MsgCommunityPoolSpend>({
+  clientResolver,
   typeUrl: MsgCommunityPoolSpend.typeUrl,
   encoders: toEncoders(MsgCommunityPoolSpend),
   converters: toConverters(MsgCommunityPoolSpend)
@@ -56,8 +56,8 @@ export const createCommunityPoolSpend = (getSigningClient: SigningClientResolver
 export const useCommunityPoolSpend = buildUseMutation<MsgCommunityPoolSpend, Error>({
   builderMutationFn: createCommunityPoolSpend
 });
-export const createDepositValidatorRewardsPool = (getSigningClient: SigningClientResolver) => buildTx<MsgDepositValidatorRewardsPool>({
-  getSigningClient: getSigningClient,
+export const createDepositValidatorRewardsPool = (clientResolver: SigningClientResolver) => buildTx<MsgDepositValidatorRewardsPool>({
+  clientResolver,
   typeUrl: MsgDepositValidatorRewardsPool.typeUrl,
   encoders: toEncoders(MsgDepositValidatorRewardsPool),
   converters: toConverters(MsgDepositValidatorRewardsPool)
diff --git a/libs/interchainjs/src/cosmos/feegrant/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/feegrant/v1beta1/tx.rpc.func.ts
index 4ecb0ea7..f2255745 100644
--- a/libs/interchainjs/src/cosmos/feegrant/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/feegrant/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgGrantAllowance, MsgRevokeAllowance, MsgPruneAllowances } from "./tx";
-export const createGrantAllowance = (getSigningClient: SigningClientResolver) => buildTx<MsgGrantAllowance>({
-  getSigningClient: getSigningClient,
+export const createGrantAllowance = (clientResolver: SigningClientResolver) => buildTx<MsgGrantAllowance>({
+  clientResolver,
   typeUrl: MsgGrantAllowance.typeUrl,
   encoders: toEncoders(MsgGrantAllowance),
   converters: toConverters(MsgGrantAllowance)
@@ -11,8 +11,8 @@ export const createGrantAllowance = (getSigningClient: SigningClientResolver) =>
 export const useGrantAllowance = buildUseMutation<MsgGrantAllowance, Error>({
   builderMutationFn: createGrantAllowance
 });
-export const createRevokeAllowance = (getSigningClient: SigningClientResolver) => buildTx<MsgRevokeAllowance>({
-  getSigningClient: getSigningClient,
+export const createRevokeAllowance = (clientResolver: SigningClientResolver) => buildTx<MsgRevokeAllowance>({
+  clientResolver,
   typeUrl: MsgRevokeAllowance.typeUrl,
   encoders: toEncoders(MsgRevokeAllowance),
   converters: toConverters(MsgRevokeAllowance)
@@ -20,8 +20,8 @@ export const createRevokeAllowance = (getSigningClient: SigningClientResolver) =
 export const useRevokeAllowance = buildUseMutation<MsgRevokeAllowance, Error>({
   builderMutationFn: createRevokeAllowance
 });
-export const createPruneAllowances = (getSigningClient: SigningClientResolver) => buildTx<MsgPruneAllowances>({
-  getSigningClient: getSigningClient,
+export const createPruneAllowances = (clientResolver: SigningClientResolver) => buildTx<MsgPruneAllowances>({
+  clientResolver,
   typeUrl: MsgPruneAllowances.typeUrl,
   encoders: toEncoders(MsgPruneAllowances),
   converters: toConverters(MsgPruneAllowances)
diff --git a/libs/interchainjs/src/cosmos/gov/v1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/gov/v1/tx.rpc.func.ts
index abb6543a..d0f94ff8 100644
--- a/libs/interchainjs/src/cosmos/gov/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/gov/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSubmitProposal, MsgExecLegacyContent, MsgVote, MsgVoteWeighted, MsgDeposit, MsgUpdateParams, MsgCancelProposal } from "./tx";
-export const createSubmitProposal = (getSigningClient: SigningClientResolver) => buildTx<MsgSubmitProposal>({
-  getSigningClient: getSigningClient,
+export const createSubmitProposal = (clientResolver: SigningClientResolver) => buildTx<MsgSubmitProposal>({
+  clientResolver,
   typeUrl: MsgSubmitProposal.typeUrl,
   encoders: toEncoders(MsgSubmitProposal),
   converters: toConverters(MsgSubmitProposal)
@@ -11,8 +11,8 @@ export const createSubmitProposal = (getSigningClient: SigningClientResolver) =>
 export const useSubmitProposal = buildUseMutation<MsgSubmitProposal, Error>({
   builderMutationFn: createSubmitProposal
 });
-export const createExecLegacyContent = (getSigningClient: SigningClientResolver) => buildTx<MsgExecLegacyContent>({
-  getSigningClient: getSigningClient,
+export const createExecLegacyContent = (clientResolver: SigningClientResolver) => buildTx<MsgExecLegacyContent>({
+  clientResolver,
   typeUrl: MsgExecLegacyContent.typeUrl,
   encoders: toEncoders(MsgExecLegacyContent),
   converters: toConverters(MsgExecLegacyContent)
@@ -20,8 +20,8 @@ export const createExecLegacyContent = (getSigningClient: SigningClientResolver)
 export const useExecLegacyContent = buildUseMutation<MsgExecLegacyContent, Error>({
   builderMutationFn: createExecLegacyContent
 });
-export const createVote = (getSigningClient: SigningClientResolver) => buildTx<MsgVote>({
-  getSigningClient: getSigningClient,
+export const createVote = (clientResolver: SigningClientResolver) => buildTx<MsgVote>({
+  clientResolver,
   typeUrl: MsgVote.typeUrl,
   encoders: toEncoders(MsgVote),
   converters: toConverters(MsgVote)
@@ -29,8 +29,8 @@ export const createVote = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useVote = buildUseMutation<MsgVote, Error>({
   builderMutationFn: createVote
 });
-export const createVoteWeighted = (getSigningClient: SigningClientResolver) => buildTx<MsgVoteWeighted>({
-  getSigningClient: getSigningClient,
+export const createVoteWeighted = (clientResolver: SigningClientResolver) => buildTx<MsgVoteWeighted>({
+  clientResolver,
   typeUrl: MsgVoteWeighted.typeUrl,
   encoders: toEncoders(MsgVoteWeighted),
   converters: toConverters(MsgVoteWeighted)
@@ -38,8 +38,8 @@ export const createVoteWeighted = (getSigningClient: SigningClientResolver) => b
 export const useVoteWeighted = buildUseMutation<MsgVoteWeighted, Error>({
   builderMutationFn: createVoteWeighted
 });
-export const createDeposit = (getSigningClient: SigningClientResolver) => buildTx<MsgDeposit>({
-  getSigningClient: getSigningClient,
+export const createDeposit = (clientResolver: SigningClientResolver) => buildTx<MsgDeposit>({
+  clientResolver,
   typeUrl: MsgDeposit.typeUrl,
   encoders: toEncoders(MsgDeposit),
   converters: toConverters(MsgDeposit)
@@ -47,8 +47,8 @@ export const createDeposit = (getSigningClient: SigningClientResolver) => buildT
 export const useDeposit = buildUseMutation<MsgDeposit, Error>({
   builderMutationFn: createDeposit
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
@@ -56,8 +56,8 @@ export const createUpdateParams = (getSigningClient: SigningClientResolver) => b
 export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
   builderMutationFn: createUpdateParams
 });
-export const createCancelProposal = (getSigningClient: SigningClientResolver) => buildTx<MsgCancelProposal>({
-  getSigningClient: getSigningClient,
+export const createCancelProposal = (clientResolver: SigningClientResolver) => buildTx<MsgCancelProposal>({
+  clientResolver,
   typeUrl: MsgCancelProposal.typeUrl,
   encoders: toEncoders(MsgCancelProposal),
   converters: toConverters(MsgCancelProposal)
diff --git a/libs/interchainjs/src/cosmos/gov/v1beta1/query.rpc.func.ts b/libs/interchainjs/src/cosmos/gov/v1beta1/query.rpc.func.ts
index 5eaf7546..3230a3a6 100644
--- a/libs/interchainjs/src/cosmos/gov/v1beta1/query.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/gov/v1beta1/query.rpc.func.ts
@@ -1,89 +1,89 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryProposalRequest, QueryProposalResponse, QueryProposalsRequest, QueryProposalsResponse, QueryVoteRequest, QueryVoteResponse, QueryVotesRequest, QueryVotesResponse, QueryParamsRequest, QueryParamsResponse, QueryDepositRequest, QueryDepositResponse, QueryDepositsRequest, QueryDepositsResponse, QueryTallyResultRequest, QueryTallyResultResponse } from "./query";
-export const createGetProposal = (getRpcInstance: RpcResolver) => buildQuery<QueryProposalRequest, QueryProposalResponse>({
+export const createGetProposal = (clientResolver: RpcResolver) => buildQuery<QueryProposalRequest, QueryProposalResponse>({
   encode: QueryProposalRequest.encode,
   decode: QueryProposalResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Proposal",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProposal = buildUseQuery<QueryProposalRequest, QueryProposalResponse>({
   builderQueryFn: createGetProposal,
   queryKeyPrefix: "ProposalQuery"
 });
-export const createGetProposals = (getRpcInstance: RpcResolver) => buildQuery<QueryProposalsRequest, QueryProposalsResponse>({
+export const createGetProposals = (clientResolver: RpcResolver) => buildQuery<QueryProposalsRequest, QueryProposalsResponse>({
   encode: QueryProposalsRequest.encode,
   decode: QueryProposalsResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Proposals",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProposals = buildUseQuery<QueryProposalsRequest, QueryProposalsResponse>({
   builderQueryFn: createGetProposals,
   queryKeyPrefix: "ProposalsQuery"
 });
-export const createGetVote = (getRpcInstance: RpcResolver) => buildQuery<QueryVoteRequest, QueryVoteResponse>({
+export const createGetVote = (clientResolver: RpcResolver) => buildQuery<QueryVoteRequest, QueryVoteResponse>({
   encode: QueryVoteRequest.encode,
   decode: QueryVoteResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Vote",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetVote = buildUseQuery<QueryVoteRequest, QueryVoteResponse>({
   builderQueryFn: createGetVote,
   queryKeyPrefix: "VoteQuery"
 });
-export const createGetVotes = (getRpcInstance: RpcResolver) => buildQuery<QueryVotesRequest, QueryVotesResponse>({
+export const createGetVotes = (clientResolver: RpcResolver) => buildQuery<QueryVotesRequest, QueryVotesResponse>({
   encode: QueryVotesRequest.encode,
   decode: QueryVotesResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Votes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetVotes = buildUseQuery<QueryVotesRequest, QueryVotesResponse>({
   builderQueryFn: createGetVotes,
   queryKeyPrefix: "VotesQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetDeposit = (getRpcInstance: RpcResolver) => buildQuery<QueryDepositRequest, QueryDepositResponse>({
+export const createGetDeposit = (clientResolver: RpcResolver) => buildQuery<QueryDepositRequest, QueryDepositResponse>({
   encode: QueryDepositRequest.encode,
   decode: QueryDepositResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Deposit",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeposit = buildUseQuery<QueryDepositRequest, QueryDepositResponse>({
   builderQueryFn: createGetDeposit,
   queryKeyPrefix: "DepositQuery"
 });
-export const createGetDeposits = (getRpcInstance: RpcResolver) => buildQuery<QueryDepositsRequest, QueryDepositsResponse>({
+export const createGetDeposits = (clientResolver: RpcResolver) => buildQuery<QueryDepositsRequest, QueryDepositsResponse>({
   encode: QueryDepositsRequest.encode,
   decode: QueryDepositsResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Deposits",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeposits = buildUseQuery<QueryDepositsRequest, QueryDepositsResponse>({
   builderQueryFn: createGetDeposits,
   queryKeyPrefix: "DepositsQuery"
 });
-export const createGetTallyResult = (getRpcInstance: RpcResolver) => buildQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
+export const createGetTallyResult = (clientResolver: RpcResolver) => buildQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
   encode: QueryTallyResultRequest.encode,
   decode: QueryTallyResultResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "TallyResult",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTallyResult = buildUseQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
   builderQueryFn: createGetTallyResult,
diff --git a/libs/interchainjs/src/cosmos/gov/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/gov/v1beta1/tx.rpc.func.ts
index f5034e44..f4a80fbd 100644
--- a/libs/interchainjs/src/cosmos/gov/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/gov/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
-export const createSubmitProposal = (getSigningClient: SigningClientResolver) => buildTx<MsgSubmitProposal>({
-  getSigningClient: getSigningClient,
+export const createSubmitProposal = (clientResolver: SigningClientResolver) => buildTx<MsgSubmitProposal>({
+  clientResolver,
   typeUrl: MsgSubmitProposal.typeUrl,
   encoders: toEncoders(MsgSubmitProposal),
   converters: toConverters(MsgSubmitProposal)
@@ -11,8 +11,8 @@ export const createSubmitProposal = (getSigningClient: SigningClientResolver) =>
 export const useSubmitProposal = buildUseMutation<MsgSubmitProposal, Error>({
   builderMutationFn: createSubmitProposal
 });
-export const createVote = (getSigningClient: SigningClientResolver) => buildTx<MsgVote>({
-  getSigningClient: getSigningClient,
+export const createVote = (clientResolver: SigningClientResolver) => buildTx<MsgVote>({
+  clientResolver,
   typeUrl: MsgVote.typeUrl,
   encoders: toEncoders(MsgVote),
   converters: toConverters(MsgVote)
@@ -20,8 +20,8 @@ export const createVote = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useVote = buildUseMutation<MsgVote, Error>({
   builderMutationFn: createVote
 });
-export const createVoteWeighted = (getSigningClient: SigningClientResolver) => buildTx<MsgVoteWeighted>({
-  getSigningClient: getSigningClient,
+export const createVoteWeighted = (clientResolver: SigningClientResolver) => buildTx<MsgVoteWeighted>({
+  clientResolver,
   typeUrl: MsgVoteWeighted.typeUrl,
   encoders: toEncoders(MsgVoteWeighted),
   converters: toConverters(MsgVoteWeighted)
@@ -29,8 +29,8 @@ export const createVoteWeighted = (getSigningClient: SigningClientResolver) => b
 export const useVoteWeighted = buildUseMutation<MsgVoteWeighted, Error>({
   builderMutationFn: createVoteWeighted
 });
-export const createDeposit = (getSigningClient: SigningClientResolver) => buildTx<MsgDeposit>({
-  getSigningClient: getSigningClient,
+export const createDeposit = (clientResolver: SigningClientResolver) => buildTx<MsgDeposit>({
+  clientResolver,
   typeUrl: MsgDeposit.typeUrl,
   encoders: toEncoders(MsgDeposit),
   converters: toConverters(MsgDeposit)
diff --git a/libs/interchainjs/src/cosmos/group/v1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/group/v1/tx.rpc.func.ts
index 82fab8b3..59f3e30e 100644
--- a/libs/interchainjs/src/cosmos/group/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/group/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateGroup, MsgUpdateGroupMembers, MsgUpdateGroupAdmin, MsgUpdateGroupMetadata, MsgCreateGroupPolicy, MsgCreateGroupWithPolicy, MsgUpdateGroupPolicyAdmin, MsgUpdateGroupPolicyDecisionPolicy, MsgUpdateGroupPolicyMetadata, MsgSubmitProposal, MsgWithdrawProposal, MsgVote, MsgExec, MsgLeaveGroup } from "./tx";
-export const createCreateGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateGroup>({
-  getSigningClient: getSigningClient,
+export const createCreateGroup = (clientResolver: SigningClientResolver) => buildTx<MsgCreateGroup>({
+  clientResolver,
   typeUrl: MsgCreateGroup.typeUrl,
   encoders: toEncoders(MsgCreateGroup),
   converters: toConverters(MsgCreateGroup)
@@ -11,8 +11,8 @@ export const createCreateGroup = (getSigningClient: SigningClientResolver) => bu
 export const useCreateGroup = buildUseMutation<MsgCreateGroup, Error>({
   builderMutationFn: createCreateGroup
 });
-export const createUpdateGroupMembers = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupMembers>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupMembers = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupMembers>({
+  clientResolver,
   typeUrl: MsgUpdateGroupMembers.typeUrl,
   encoders: toEncoders(MsgUpdateGroupMembers),
   converters: toConverters(MsgUpdateGroupMembers)
@@ -20,8 +20,8 @@ export const createUpdateGroupMembers = (getSigningClient: SigningClientResolver
 export const useUpdateGroupMembers = buildUseMutation<MsgUpdateGroupMembers, Error>({
   builderMutationFn: createUpdateGroupMembers
 });
-export const createUpdateGroupAdmin = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupAdmin>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupAdmin = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupAdmin>({
+  clientResolver,
   typeUrl: MsgUpdateGroupAdmin.typeUrl,
   encoders: toEncoders(MsgUpdateGroupAdmin),
   converters: toConverters(MsgUpdateGroupAdmin)
@@ -29,8 +29,8 @@ export const createUpdateGroupAdmin = (getSigningClient: SigningClientResolver)
 export const useUpdateGroupAdmin = buildUseMutation<MsgUpdateGroupAdmin, Error>({
   builderMutationFn: createUpdateGroupAdmin
 });
-export const createUpdateGroupMetadata = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupMetadata>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupMetadata = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupMetadata>({
+  clientResolver,
   typeUrl: MsgUpdateGroupMetadata.typeUrl,
   encoders: toEncoders(MsgUpdateGroupMetadata),
   converters: toConverters(MsgUpdateGroupMetadata)
@@ -38,8 +38,8 @@ export const createUpdateGroupMetadata = (getSigningClient: SigningClientResolve
 export const useUpdateGroupMetadata = buildUseMutation<MsgUpdateGroupMetadata, Error>({
   builderMutationFn: createUpdateGroupMetadata
 });
-export const createCreateGroupPolicy = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateGroupPolicy>({
-  getSigningClient: getSigningClient,
+export const createCreateGroupPolicy = (clientResolver: SigningClientResolver) => buildTx<MsgCreateGroupPolicy>({
+  clientResolver,
   typeUrl: MsgCreateGroupPolicy.typeUrl,
   encoders: toEncoders(MsgCreateGroupPolicy),
   converters: toConverters(MsgCreateGroupPolicy)
@@ -47,8 +47,8 @@ export const createCreateGroupPolicy = (getSigningClient: SigningClientResolver)
 export const useCreateGroupPolicy = buildUseMutation<MsgCreateGroupPolicy, Error>({
   builderMutationFn: createCreateGroupPolicy
 });
-export const createCreateGroupWithPolicy = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateGroupWithPolicy>({
-  getSigningClient: getSigningClient,
+export const createCreateGroupWithPolicy = (clientResolver: SigningClientResolver) => buildTx<MsgCreateGroupWithPolicy>({
+  clientResolver,
   typeUrl: MsgCreateGroupWithPolicy.typeUrl,
   encoders: toEncoders(MsgCreateGroupWithPolicy),
   converters: toConverters(MsgCreateGroupWithPolicy)
@@ -56,8 +56,8 @@ export const createCreateGroupWithPolicy = (getSigningClient: SigningClientResol
 export const useCreateGroupWithPolicy = buildUseMutation<MsgCreateGroupWithPolicy, Error>({
   builderMutationFn: createCreateGroupWithPolicy
 });
-export const createUpdateGroupPolicyAdmin = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyAdmin>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupPolicyAdmin = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyAdmin>({
+  clientResolver,
   typeUrl: MsgUpdateGroupPolicyAdmin.typeUrl,
   encoders: toEncoders(MsgUpdateGroupPolicyAdmin),
   converters: toConverters(MsgUpdateGroupPolicyAdmin)
@@ -65,8 +65,8 @@ export const createUpdateGroupPolicyAdmin = (getSigningClient: SigningClientReso
 export const useUpdateGroupPolicyAdmin = buildUseMutation<MsgUpdateGroupPolicyAdmin, Error>({
   builderMutationFn: createUpdateGroupPolicyAdmin
 });
-export const createUpdateGroupPolicyDecisionPolicy = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyDecisionPolicy>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupPolicyDecisionPolicy = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyDecisionPolicy>({
+  clientResolver,
   typeUrl: MsgUpdateGroupPolicyDecisionPolicy.typeUrl,
   encoders: toEncoders(MsgUpdateGroupPolicyDecisionPolicy),
   converters: toConverters(MsgUpdateGroupPolicyDecisionPolicy)
@@ -74,8 +74,8 @@ export const createUpdateGroupPolicyDecisionPolicy = (getSigningClient: SigningC
 export const useUpdateGroupPolicyDecisionPolicy = buildUseMutation<MsgUpdateGroupPolicyDecisionPolicy, Error>({
   builderMutationFn: createUpdateGroupPolicyDecisionPolicy
 });
-export const createUpdateGroupPolicyMetadata = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyMetadata>({
-  getSigningClient: getSigningClient,
+export const createUpdateGroupPolicyMetadata = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateGroupPolicyMetadata>({
+  clientResolver,
   typeUrl: MsgUpdateGroupPolicyMetadata.typeUrl,
   encoders: toEncoders(MsgUpdateGroupPolicyMetadata),
   converters: toConverters(MsgUpdateGroupPolicyMetadata)
@@ -83,8 +83,8 @@ export const createUpdateGroupPolicyMetadata = (getSigningClient: SigningClientR
 export const useUpdateGroupPolicyMetadata = buildUseMutation<MsgUpdateGroupPolicyMetadata, Error>({
   builderMutationFn: createUpdateGroupPolicyMetadata
 });
-export const createSubmitProposal = (getSigningClient: SigningClientResolver) => buildTx<MsgSubmitProposal>({
-  getSigningClient: getSigningClient,
+export const createSubmitProposal = (clientResolver: SigningClientResolver) => buildTx<MsgSubmitProposal>({
+  clientResolver,
   typeUrl: MsgSubmitProposal.typeUrl,
   encoders: toEncoders(MsgSubmitProposal),
   converters: toConverters(MsgSubmitProposal)
@@ -92,8 +92,8 @@ export const createSubmitProposal = (getSigningClient: SigningClientResolver) =>
 export const useSubmitProposal = buildUseMutation<MsgSubmitProposal, Error>({
   builderMutationFn: createSubmitProposal
 });
-export const createWithdrawProposal = (getSigningClient: SigningClientResolver) => buildTx<MsgWithdrawProposal>({
-  getSigningClient: getSigningClient,
+export const createWithdrawProposal = (clientResolver: SigningClientResolver) => buildTx<MsgWithdrawProposal>({
+  clientResolver,
   typeUrl: MsgWithdrawProposal.typeUrl,
   encoders: toEncoders(MsgWithdrawProposal),
   converters: toConverters(MsgWithdrawProposal)
@@ -101,8 +101,8 @@ export const createWithdrawProposal = (getSigningClient: SigningClientResolver)
 export const useWithdrawProposal = buildUseMutation<MsgWithdrawProposal, Error>({
   builderMutationFn: createWithdrawProposal
 });
-export const createVote = (getSigningClient: SigningClientResolver) => buildTx<MsgVote>({
-  getSigningClient: getSigningClient,
+export const createVote = (clientResolver: SigningClientResolver) => buildTx<MsgVote>({
+  clientResolver,
   typeUrl: MsgVote.typeUrl,
   encoders: toEncoders(MsgVote),
   converters: toConverters(MsgVote)
@@ -110,8 +110,8 @@ export const createVote = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useVote = buildUseMutation<MsgVote, Error>({
   builderMutationFn: createVote
 });
-export const createExec = (getSigningClient: SigningClientResolver) => buildTx<MsgExec>({
-  getSigningClient: getSigningClient,
+export const createExec = (clientResolver: SigningClientResolver) => buildTx<MsgExec>({
+  clientResolver,
   typeUrl: MsgExec.typeUrl,
   encoders: toEncoders(MsgExec),
   converters: toConverters(MsgExec)
@@ -119,8 +119,8 @@ export const createExec = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useExec = buildUseMutation<MsgExec, Error>({
   builderMutationFn: createExec
 });
-export const createLeaveGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgLeaveGroup>({
-  getSigningClient: getSigningClient,
+export const createLeaveGroup = (clientResolver: SigningClientResolver) => buildTx<MsgLeaveGroup>({
+  clientResolver,
   typeUrl: MsgLeaveGroup.typeUrl,
   encoders: toEncoders(MsgLeaveGroup),
   converters: toConverters(MsgLeaveGroup)
diff --git a/libs/interchainjs/src/cosmos/staking/v1beta1/query.rpc.func.ts b/libs/interchainjs/src/cosmos/staking/v1beta1/query.rpc.func.ts
index c85d8e39..e91b667b 100644
--- a/libs/interchainjs/src/cosmos/staking/v1beta1/query.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/staking/v1beta1/query.rpc.func.ts
@@ -1,155 +1,155 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryValidatorsRequest, QueryValidatorsResponse, QueryValidatorRequest, QueryValidatorResponse, QueryValidatorDelegationsRequest, QueryValidatorDelegationsResponse, QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponse, QueryDelegationRequest, QueryDelegationResponse, QueryUnbondingDelegationRequest, QueryUnbondingDelegationResponse, QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsResponse, QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsResponse, QueryRedelegationsRequest, QueryRedelegationsResponse, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse, QueryDelegatorValidatorRequest, QueryDelegatorValidatorResponse, QueryHistoricalInfoRequest, QueryHistoricalInfoResponse, QueryPoolRequest, QueryPoolResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetValidators = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorsRequest, QueryValidatorsResponse>({
+export const createGetValidators = (clientResolver: RpcResolver) => buildQuery<QueryValidatorsRequest, QueryValidatorsResponse>({
   encode: QueryValidatorsRequest.encode,
   decode: QueryValidatorsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Validators",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidators = buildUseQuery<QueryValidatorsRequest, QueryValidatorsResponse>({
   builderQueryFn: createGetValidators,
   queryKeyPrefix: "ValidatorsQuery"
 });
-export const createGetValidator = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorRequest, QueryValidatorResponse>({
+export const createGetValidator = (clientResolver: RpcResolver) => buildQuery<QueryValidatorRequest, QueryValidatorResponse>({
   encode: QueryValidatorRequest.encode,
   decode: QueryValidatorResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Validator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidator = buildUseQuery<QueryValidatorRequest, QueryValidatorResponse>({
   builderQueryFn: createGetValidator,
   queryKeyPrefix: "ValidatorQuery"
 });
-export const createGetValidatorDelegations = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorDelegationsRequest, QueryValidatorDelegationsResponse>({
+export const createGetValidatorDelegations = (clientResolver: RpcResolver) => buildQuery<QueryValidatorDelegationsRequest, QueryValidatorDelegationsResponse>({
   encode: QueryValidatorDelegationsRequest.encode,
   decode: QueryValidatorDelegationsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "ValidatorDelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidatorDelegations = buildUseQuery<QueryValidatorDelegationsRequest, QueryValidatorDelegationsResponse>({
   builderQueryFn: createGetValidatorDelegations,
   queryKeyPrefix: "ValidatorDelegationsQuery"
 });
-export const createGetValidatorUnbondingDelegations = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponse>({
+export const createGetValidatorUnbondingDelegations = (clientResolver: RpcResolver) => buildQuery<QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponse>({
   encode: QueryValidatorUnbondingDelegationsRequest.encode,
   decode: QueryValidatorUnbondingDelegationsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "ValidatorUnbondingDelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidatorUnbondingDelegations = buildUseQuery<QueryValidatorUnbondingDelegationsRequest, QueryValidatorUnbondingDelegationsResponse>({
   builderQueryFn: createGetValidatorUnbondingDelegations,
   queryKeyPrefix: "ValidatorUnbondingDelegationsQuery"
 });
-export const createGetDelegation = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegationRequest, QueryDelegationResponse>({
+export const createGetDelegation = (clientResolver: RpcResolver) => buildQuery<QueryDelegationRequest, QueryDelegationResponse>({
   encode: QueryDelegationRequest.encode,
   decode: QueryDelegationResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Delegation",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegation = buildUseQuery<QueryDelegationRequest, QueryDelegationResponse>({
   builderQueryFn: createGetDelegation,
   queryKeyPrefix: "DelegationQuery"
 });
-export const createGetUnbondingDelegation = (getRpcInstance: RpcResolver) => buildQuery<QueryUnbondingDelegationRequest, QueryUnbondingDelegationResponse>({
+export const createGetUnbondingDelegation = (clientResolver: RpcResolver) => buildQuery<QueryUnbondingDelegationRequest, QueryUnbondingDelegationResponse>({
   encode: QueryUnbondingDelegationRequest.encode,
   decode: QueryUnbondingDelegationResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "UnbondingDelegation",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUnbondingDelegation = buildUseQuery<QueryUnbondingDelegationRequest, QueryUnbondingDelegationResponse>({
   builderQueryFn: createGetUnbondingDelegation,
   queryKeyPrefix: "UnbondingDelegationQuery"
 });
-export const createGetDelegatorDelegations = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsResponse>({
+export const createGetDelegatorDelegations = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsResponse>({
   encode: QueryDelegatorDelegationsRequest.encode,
   decode: QueryDelegatorDelegationsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "DelegatorDelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorDelegations = buildUseQuery<QueryDelegatorDelegationsRequest, QueryDelegatorDelegationsResponse>({
   builderQueryFn: createGetDelegatorDelegations,
   queryKeyPrefix: "DelegatorDelegationsQuery"
 });
-export const createGetDelegatorUnbondingDelegations = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsResponse>({
+export const createGetDelegatorUnbondingDelegations = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsResponse>({
   encode: QueryDelegatorUnbondingDelegationsRequest.encode,
   decode: QueryDelegatorUnbondingDelegationsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "DelegatorUnbondingDelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorUnbondingDelegations = buildUseQuery<QueryDelegatorUnbondingDelegationsRequest, QueryDelegatorUnbondingDelegationsResponse>({
   builderQueryFn: createGetDelegatorUnbondingDelegations,
   queryKeyPrefix: "DelegatorUnbondingDelegationsQuery"
 });
-export const createGetRedelegations = (getRpcInstance: RpcResolver) => buildQuery<QueryRedelegationsRequest, QueryRedelegationsResponse>({
+export const createGetRedelegations = (clientResolver: RpcResolver) => buildQuery<QueryRedelegationsRequest, QueryRedelegationsResponse>({
   encode: QueryRedelegationsRequest.encode,
   decode: QueryRedelegationsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Redelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetRedelegations = buildUseQuery<QueryRedelegationsRequest, QueryRedelegationsResponse>({
   builderQueryFn: createGetRedelegations,
   queryKeyPrefix: "RedelegationsQuery"
 });
-export const createGetDelegatorValidators = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
+export const createGetDelegatorValidators = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
   encode: QueryDelegatorValidatorsRequest.encode,
   decode: QueryDelegatorValidatorsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "DelegatorValidators",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorValidators = buildUseQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
   builderQueryFn: createGetDelegatorValidators,
   queryKeyPrefix: "DelegatorValidatorsQuery"
 });
-export const createGetDelegatorValidator = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorValidatorRequest, QueryDelegatorValidatorResponse>({
+export const createGetDelegatorValidator = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorValidatorRequest, QueryDelegatorValidatorResponse>({
   encode: QueryDelegatorValidatorRequest.encode,
   decode: QueryDelegatorValidatorResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "DelegatorValidator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorValidator = buildUseQuery<QueryDelegatorValidatorRequest, QueryDelegatorValidatorResponse>({
   builderQueryFn: createGetDelegatorValidator,
   queryKeyPrefix: "DelegatorValidatorQuery"
 });
-export const createGetHistoricalInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryHistoricalInfoRequest, QueryHistoricalInfoResponse>({
+export const createGetHistoricalInfo = (clientResolver: RpcResolver) => buildQuery<QueryHistoricalInfoRequest, QueryHistoricalInfoResponse>({
   encode: QueryHistoricalInfoRequest.encode,
   decode: QueryHistoricalInfoResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "HistoricalInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetHistoricalInfo = buildUseQuery<QueryHistoricalInfoRequest, QueryHistoricalInfoResponse>({
   builderQueryFn: createGetHistoricalInfo,
   queryKeyPrefix: "HistoricalInfoQuery"
 });
-export const createGetPool = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolRequest, QueryPoolResponse>({
+export const createGetPool = (clientResolver: RpcResolver) => buildQuery<QueryPoolRequest, QueryPoolResponse>({
   encode: QueryPoolRequest.encode,
   decode: QueryPoolResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Pool",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPool = buildUseQuery<QueryPoolRequest, QueryPoolResponse>({
   builderQueryFn: createGetPool,
   queryKeyPrefix: "PoolQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.staking.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/libs/interchainjs/src/cosmos/staking/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/staking/v1beta1/tx.rpc.func.ts
index f44013e9..9e2ff852 100644
--- a/libs/interchainjs/src/cosmos/staking/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/staking/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateValidator, MsgEditValidator, MsgDelegate, MsgBeginRedelegate, MsgUndelegate, MsgCancelUnbondingDelegation, MsgUpdateParams } from "./tx";
-export const createCreateValidator = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateValidator>({
-  getSigningClient: getSigningClient,
+export const createCreateValidator = (clientResolver: SigningClientResolver) => buildTx<MsgCreateValidator>({
+  clientResolver,
   typeUrl: MsgCreateValidator.typeUrl,
   encoders: toEncoders(MsgCreateValidator),
   converters: toConverters(MsgCreateValidator)
@@ -11,8 +11,8 @@ export const createCreateValidator = (getSigningClient: SigningClientResolver) =
 export const useCreateValidator = buildUseMutation<MsgCreateValidator, Error>({
   builderMutationFn: createCreateValidator
 });
-export const createEditValidator = (getSigningClient: SigningClientResolver) => buildTx<MsgEditValidator>({
-  getSigningClient: getSigningClient,
+export const createEditValidator = (clientResolver: SigningClientResolver) => buildTx<MsgEditValidator>({
+  clientResolver,
   typeUrl: MsgEditValidator.typeUrl,
   encoders: toEncoders(MsgEditValidator),
   converters: toConverters(MsgEditValidator)
@@ -20,8 +20,8 @@ export const createEditValidator = (getSigningClient: SigningClientResolver) =>
 export const useEditValidator = buildUseMutation<MsgEditValidator, Error>({
   builderMutationFn: createEditValidator
 });
-export const createDelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgDelegate>({
-  getSigningClient: getSigningClient,
+export const createDelegate = (clientResolver: SigningClientResolver) => buildTx<MsgDelegate>({
+  clientResolver,
   typeUrl: MsgDelegate.typeUrl,
   encoders: toEncoders(MsgDelegate),
   converters: toConverters(MsgDelegate)
@@ -29,8 +29,8 @@ export const createDelegate = (getSigningClient: SigningClientResolver) => build
 export const useDelegate = buildUseMutation<MsgDelegate, Error>({
   builderMutationFn: createDelegate
 });
-export const createBeginRedelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgBeginRedelegate>({
-  getSigningClient: getSigningClient,
+export const createBeginRedelegate = (clientResolver: SigningClientResolver) => buildTx<MsgBeginRedelegate>({
+  clientResolver,
   typeUrl: MsgBeginRedelegate.typeUrl,
   encoders: toEncoders(MsgBeginRedelegate),
   converters: toConverters(MsgBeginRedelegate)
@@ -38,8 +38,8 @@ export const createBeginRedelegate = (getSigningClient: SigningClientResolver) =
 export const useBeginRedelegate = buildUseMutation<MsgBeginRedelegate, Error>({
   builderMutationFn: createBeginRedelegate
 });
-export const createUndelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgUndelegate>({
-  getSigningClient: getSigningClient,
+export const createUndelegate = (clientResolver: SigningClientResolver) => buildTx<MsgUndelegate>({
+  clientResolver,
   typeUrl: MsgUndelegate.typeUrl,
   encoders: toEncoders(MsgUndelegate),
   converters: toConverters(MsgUndelegate)
@@ -47,8 +47,8 @@ export const createUndelegate = (getSigningClient: SigningClientResolver) => bui
 export const useUndelegate = buildUseMutation<MsgUndelegate, Error>({
   builderMutationFn: createUndelegate
 });
-export const createCancelUnbondingDelegation = (getSigningClient: SigningClientResolver) => buildTx<MsgCancelUnbondingDelegation>({
-  getSigningClient: getSigningClient,
+export const createCancelUnbondingDelegation = (clientResolver: SigningClientResolver) => buildTx<MsgCancelUnbondingDelegation>({
+  clientResolver,
   typeUrl: MsgCancelUnbondingDelegation.typeUrl,
   encoders: toEncoders(MsgCancelUnbondingDelegation),
   converters: toConverters(MsgCancelUnbondingDelegation)
@@ -56,8 +56,8 @@ export const createCancelUnbondingDelegation = (getSigningClient: SigningClientR
 export const useCancelUnbondingDelegation = buildUseMutation<MsgCancelUnbondingDelegation, Error>({
   builderMutationFn: createCancelUnbondingDelegation
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
diff --git a/libs/interchainjs/src/cosmos/tx/v1beta1/service.rpc.func.ts b/libs/interchainjs/src/cosmos/tx/v1beta1/service.rpc.func.ts
index a445788a..4adb2ea0 100644
--- a/libs/interchainjs/src/cosmos/tx/v1beta1/service.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/tx/v1beta1/service.rpc.func.ts
@@ -1,100 +1,100 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { SimulateRequest, SimulateResponse, GetTxRequest, GetTxResponse, BroadcastTxRequest, BroadcastTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse, TxDecodeRequest, TxDecodeResponse, TxEncodeRequest, TxEncodeResponse, TxEncodeAminoRequest, TxEncodeAminoResponse, TxDecodeAminoRequest, TxDecodeAminoResponse } from "./service";
-export const createGetSimulate = (getRpcInstance: RpcResolver) => buildQuery<SimulateRequest, SimulateResponse>({
+export const createGetSimulate = (clientResolver: RpcResolver) => buildQuery<SimulateRequest, SimulateResponse>({
   encode: SimulateRequest.encode,
   decode: SimulateResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "Simulate",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSimulate = buildUseQuery<SimulateRequest, SimulateResponse>({
   builderQueryFn: createGetSimulate,
   queryKeyPrefix: "SimulateQuery"
 });
-export const createGetGetTx = (getRpcInstance: RpcResolver) => buildQuery<GetTxRequest, GetTxResponse>({
+export const createGetGetTx = (clientResolver: RpcResolver) => buildQuery<GetTxRequest, GetTxResponse>({
   encode: GetTxRequest.encode,
   decode: GetTxResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "GetTx",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetTx = buildUseQuery<GetTxRequest, GetTxResponse>({
   builderQueryFn: createGetGetTx,
   queryKeyPrefix: "GetTxQuery"
 });
-export const createGetBroadcastTx = (getRpcInstance: RpcResolver) => buildQuery<BroadcastTxRequest, BroadcastTxResponse>({
+export const createGetBroadcastTx = (clientResolver: RpcResolver) => buildQuery<BroadcastTxRequest, BroadcastTxResponse>({
   encode: BroadcastTxRequest.encode,
   decode: BroadcastTxResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "BroadcastTx",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBroadcastTx = buildUseQuery<BroadcastTxRequest, BroadcastTxResponse>({
   builderQueryFn: createGetBroadcastTx,
   queryKeyPrefix: "BroadcastTxQuery"
 });
-export const createGetGetTxsEvent = (getRpcInstance: RpcResolver) => buildQuery<GetTxsEventRequest, GetTxsEventResponse>({
+export const createGetGetTxsEvent = (clientResolver: RpcResolver) => buildQuery<GetTxsEventRequest, GetTxsEventResponse>({
   encode: GetTxsEventRequest.encode,
   decode: GetTxsEventResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "GetTxsEvent",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetTxsEvent = buildUseQuery<GetTxsEventRequest, GetTxsEventResponse>({
   builderQueryFn: createGetGetTxsEvent,
   queryKeyPrefix: "GetTxsEventQuery"
 });
-export const createGetGetBlockWithTxs = (getRpcInstance: RpcResolver) => buildQuery<GetBlockWithTxsRequest, GetBlockWithTxsResponse>({
+export const createGetGetBlockWithTxs = (clientResolver: RpcResolver) => buildQuery<GetBlockWithTxsRequest, GetBlockWithTxsResponse>({
   encode: GetBlockWithTxsRequest.encode,
   decode: GetBlockWithTxsResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "GetBlockWithTxs",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetBlockWithTxs = buildUseQuery<GetBlockWithTxsRequest, GetBlockWithTxsResponse>({
   builderQueryFn: createGetGetBlockWithTxs,
   queryKeyPrefix: "GetBlockWithTxsQuery"
 });
-export const createGetTxDecode = (getRpcInstance: RpcResolver) => buildQuery<TxDecodeRequest, TxDecodeResponse>({
+export const createGetTxDecode = (clientResolver: RpcResolver) => buildQuery<TxDecodeRequest, TxDecodeResponse>({
   encode: TxDecodeRequest.encode,
   decode: TxDecodeResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "TxDecode",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTxDecode = buildUseQuery<TxDecodeRequest, TxDecodeResponse>({
   builderQueryFn: createGetTxDecode,
   queryKeyPrefix: "TxDecodeQuery"
 });
-export const createGetTxEncode = (getRpcInstance: RpcResolver) => buildQuery<TxEncodeRequest, TxEncodeResponse>({
+export const createGetTxEncode = (clientResolver: RpcResolver) => buildQuery<TxEncodeRequest, TxEncodeResponse>({
   encode: TxEncodeRequest.encode,
   decode: TxEncodeResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "TxEncode",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTxEncode = buildUseQuery<TxEncodeRequest, TxEncodeResponse>({
   builderQueryFn: createGetTxEncode,
   queryKeyPrefix: "TxEncodeQuery"
 });
-export const createGetTxEncodeAmino = (getRpcInstance: RpcResolver) => buildQuery<TxEncodeAminoRequest, TxEncodeAminoResponse>({
+export const createGetTxEncodeAmino = (clientResolver: RpcResolver) => buildQuery<TxEncodeAminoRequest, TxEncodeAminoResponse>({
   encode: TxEncodeAminoRequest.encode,
   decode: TxEncodeAminoResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "TxEncodeAmino",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTxEncodeAmino = buildUseQuery<TxEncodeAminoRequest, TxEncodeAminoResponse>({
   builderQueryFn: createGetTxEncodeAmino,
   queryKeyPrefix: "TxEncodeAminoQuery"
 });
-export const createGetTxDecodeAmino = (getRpcInstance: RpcResolver) => buildQuery<TxDecodeAminoRequest, TxDecodeAminoResponse>({
+export const createGetTxDecodeAmino = (clientResolver: RpcResolver) => buildQuery<TxDecodeAminoRequest, TxDecodeAminoResponse>({
   encode: TxDecodeAminoRequest.encode,
   decode: TxDecodeAminoResponse.decode,
   service: "cosmos.tx.v1beta1.Service",
   method: "TxDecodeAmino",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTxDecodeAmino = buildUseQuery<TxDecodeAminoRequest, TxDecodeAminoResponse>({
   builderQueryFn: createGetTxDecodeAmino,
diff --git a/libs/interchainjs/src/cosmos/vesting/v1beta1/tx.rpc.func.ts b/libs/interchainjs/src/cosmos/vesting/v1beta1/tx.rpc.func.ts
index 6168e11e..b54ec88f 100644
--- a/libs/interchainjs/src/cosmos/vesting/v1beta1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmos/vesting/v1beta1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateVestingAccount, MsgCreatePermanentLockedAccount, MsgCreatePeriodicVestingAccount } from "./tx";
-export const createCreateVestingAccount = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateVestingAccount>({
-  getSigningClient: getSigningClient,
+export const createCreateVestingAccount = (clientResolver: SigningClientResolver) => buildTx<MsgCreateVestingAccount>({
+  clientResolver,
   typeUrl: MsgCreateVestingAccount.typeUrl,
   encoders: toEncoders(MsgCreateVestingAccount),
   converters: toConverters(MsgCreateVestingAccount)
@@ -11,8 +11,8 @@ export const createCreateVestingAccount = (getSigningClient: SigningClientResolv
 export const useCreateVestingAccount = buildUseMutation<MsgCreateVestingAccount, Error>({
   builderMutationFn: createCreateVestingAccount
 });
-export const createCreatePermanentLockedAccount = (getSigningClient: SigningClientResolver) => buildTx<MsgCreatePermanentLockedAccount>({
-  getSigningClient: getSigningClient,
+export const createCreatePermanentLockedAccount = (clientResolver: SigningClientResolver) => buildTx<MsgCreatePermanentLockedAccount>({
+  clientResolver,
   typeUrl: MsgCreatePermanentLockedAccount.typeUrl,
   encoders: toEncoders(MsgCreatePermanentLockedAccount),
   converters: toConverters(MsgCreatePermanentLockedAccount)
@@ -20,8 +20,8 @@ export const createCreatePermanentLockedAccount = (getSigningClient: SigningClie
 export const useCreatePermanentLockedAccount = buildUseMutation<MsgCreatePermanentLockedAccount, Error>({
   builderMutationFn: createCreatePermanentLockedAccount
 });
-export const createCreatePeriodicVestingAccount = (getSigningClient: SigningClientResolver) => buildTx<MsgCreatePeriodicVestingAccount>({
-  getSigningClient: getSigningClient,
+export const createCreatePeriodicVestingAccount = (clientResolver: SigningClientResolver) => buildTx<MsgCreatePeriodicVestingAccount>({
+  clientResolver,
   typeUrl: MsgCreatePeriodicVestingAccount.typeUrl,
   encoders: toEncoders(MsgCreatePeriodicVestingAccount),
   converters: toConverters(MsgCreatePeriodicVestingAccount)
diff --git a/libs/interchainjs/src/cosmwasm/wasm/v1/query.rpc.func.ts b/libs/interchainjs/src/cosmwasm/wasm/v1/query.rpc.func.ts
index 94536b7e..e83c52a0 100644
--- a/libs/interchainjs/src/cosmwasm/wasm/v1/query.rpc.func.ts
+++ b/libs/interchainjs/src/cosmwasm/wasm/v1/query.rpc.func.ts
@@ -1,133 +1,133 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryContractInfoRequest, QueryContractInfoResponse, QueryContractHistoryRequest, QueryContractHistoryResponse, QueryContractsByCodeRequest, QueryContractsByCodeResponse, QueryAllContractStateRequest, QueryAllContractStateResponse, QueryRawContractStateRequest, QueryRawContractStateResponse, QuerySmartContractStateRequest, QuerySmartContractStateResponse, QueryCodeRequest, QueryCodeResponse, QueryCodesRequest, QueryCodesResponse, QueryPinnedCodesRequest, QueryPinnedCodesResponse, QueryParamsRequest, QueryParamsResponse, QueryContractsByCreatorRequest, QueryContractsByCreatorResponse, QueryBuildAddressRequest, QueryBuildAddressResponse } from "./query";
-export const createGetContractInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryContractInfoRequest, QueryContractInfoResponse>({
+export const createGetContractInfo = (clientResolver: RpcResolver) => buildQuery<QueryContractInfoRequest, QueryContractInfoResponse>({
   encode: QueryContractInfoRequest.encode,
   decode: QueryContractInfoResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "ContractInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetContractInfo = buildUseQuery<QueryContractInfoRequest, QueryContractInfoResponse>({
   builderQueryFn: createGetContractInfo,
   queryKeyPrefix: "ContractInfoQuery"
 });
-export const createGetContractHistory = (getRpcInstance: RpcResolver) => buildQuery<QueryContractHistoryRequest, QueryContractHistoryResponse>({
+export const createGetContractHistory = (clientResolver: RpcResolver) => buildQuery<QueryContractHistoryRequest, QueryContractHistoryResponse>({
   encode: QueryContractHistoryRequest.encode,
   decode: QueryContractHistoryResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "ContractHistory",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetContractHistory = buildUseQuery<QueryContractHistoryRequest, QueryContractHistoryResponse>({
   builderQueryFn: createGetContractHistory,
   queryKeyPrefix: "ContractHistoryQuery"
 });
-export const createGetContractsByCode = (getRpcInstance: RpcResolver) => buildQuery<QueryContractsByCodeRequest, QueryContractsByCodeResponse>({
+export const createGetContractsByCode = (clientResolver: RpcResolver) => buildQuery<QueryContractsByCodeRequest, QueryContractsByCodeResponse>({
   encode: QueryContractsByCodeRequest.encode,
   decode: QueryContractsByCodeResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "ContractsByCode",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetContractsByCode = buildUseQuery<QueryContractsByCodeRequest, QueryContractsByCodeResponse>({
   builderQueryFn: createGetContractsByCode,
   queryKeyPrefix: "ContractsByCodeQuery"
 });
-export const createGetAllContractState = (getRpcInstance: RpcResolver) => buildQuery<QueryAllContractStateRequest, QueryAllContractStateResponse>({
+export const createGetAllContractState = (clientResolver: RpcResolver) => buildQuery<QueryAllContractStateRequest, QueryAllContractStateResponse>({
   encode: QueryAllContractStateRequest.encode,
   decode: QueryAllContractStateResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "AllContractState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllContractState = buildUseQuery<QueryAllContractStateRequest, QueryAllContractStateResponse>({
   builderQueryFn: createGetAllContractState,
   queryKeyPrefix: "AllContractStateQuery"
 });
-export const createGetRawContractState = (getRpcInstance: RpcResolver) => buildQuery<QueryRawContractStateRequest, QueryRawContractStateResponse>({
+export const createGetRawContractState = (clientResolver: RpcResolver) => buildQuery<QueryRawContractStateRequest, QueryRawContractStateResponse>({
   encode: QueryRawContractStateRequest.encode,
   decode: QueryRawContractStateResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "RawContractState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetRawContractState = buildUseQuery<QueryRawContractStateRequest, QueryRawContractStateResponse>({
   builderQueryFn: createGetRawContractState,
   queryKeyPrefix: "RawContractStateQuery"
 });
-export const createGetSmartContractState = (getRpcInstance: RpcResolver) => buildQuery<QuerySmartContractStateRequest, QuerySmartContractStateResponse>({
+export const createGetSmartContractState = (clientResolver: RpcResolver) => buildQuery<QuerySmartContractStateRequest, QuerySmartContractStateResponse>({
   encode: QuerySmartContractStateRequest.encode,
   decode: QuerySmartContractStateResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "SmartContractState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSmartContractState = buildUseQuery<QuerySmartContractStateRequest, QuerySmartContractStateResponse>({
   builderQueryFn: createGetSmartContractState,
   queryKeyPrefix: "SmartContractStateQuery"
 });
-export const createGetCode = (getRpcInstance: RpcResolver) => buildQuery<QueryCodeRequest, QueryCodeResponse>({
+export const createGetCode = (clientResolver: RpcResolver) => buildQuery<QueryCodeRequest, QueryCodeResponse>({
   encode: QueryCodeRequest.encode,
   decode: QueryCodeResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "Code",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCode = buildUseQuery<QueryCodeRequest, QueryCodeResponse>({
   builderQueryFn: createGetCode,
   queryKeyPrefix: "CodeQuery"
 });
-export const createGetCodes = (getRpcInstance: RpcResolver) => buildQuery<QueryCodesRequest, QueryCodesResponse>({
+export const createGetCodes = (clientResolver: RpcResolver) => buildQuery<QueryCodesRequest, QueryCodesResponse>({
   encode: QueryCodesRequest.encode,
   decode: QueryCodesResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "Codes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCodes = buildUseQuery<QueryCodesRequest, QueryCodesResponse>({
   builderQueryFn: createGetCodes,
   queryKeyPrefix: "CodesQuery"
 });
-export const createGetPinnedCodes = (getRpcInstance: RpcResolver) => buildQuery<QueryPinnedCodesRequest, QueryPinnedCodesResponse>({
+export const createGetPinnedCodes = (clientResolver: RpcResolver) => buildQuery<QueryPinnedCodesRequest, QueryPinnedCodesResponse>({
   encode: QueryPinnedCodesRequest.encode,
   decode: QueryPinnedCodesResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "PinnedCodes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPinnedCodes = buildUseQuery<QueryPinnedCodesRequest, QueryPinnedCodesResponse>({
   builderQueryFn: createGetPinnedCodes,
   queryKeyPrefix: "PinnedCodesQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetContractsByCreator = (getRpcInstance: RpcResolver) => buildQuery<QueryContractsByCreatorRequest, QueryContractsByCreatorResponse>({
+export const createGetContractsByCreator = (clientResolver: RpcResolver) => buildQuery<QueryContractsByCreatorRequest, QueryContractsByCreatorResponse>({
   encode: QueryContractsByCreatorRequest.encode,
   decode: QueryContractsByCreatorResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "ContractsByCreator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetContractsByCreator = buildUseQuery<QueryContractsByCreatorRequest, QueryContractsByCreatorResponse>({
   builderQueryFn: createGetContractsByCreator,
   queryKeyPrefix: "ContractsByCreatorQuery"
 });
-export const createGetBuildAddress = (getRpcInstance: RpcResolver) => buildQuery<QueryBuildAddressRequest, QueryBuildAddressResponse>({
+export const createGetBuildAddress = (clientResolver: RpcResolver) => buildQuery<QueryBuildAddressRequest, QueryBuildAddressResponse>({
   encode: QueryBuildAddressRequest.encode,
   decode: QueryBuildAddressResponse.decode,
   service: "cosmwasm.wasm.v1.Query",
   method: "BuildAddress",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBuildAddress = buildUseQuery<QueryBuildAddressRequest, QueryBuildAddressResponse>({
   builderQueryFn: createGetBuildAddress,
diff --git a/libs/interchainjs/src/cosmwasm/wasm/v1/tx.rpc.func.ts b/libs/interchainjs/src/cosmwasm/wasm/v1/tx.rpc.func.ts
index cde6c3ca..ce99df24 100644
--- a/libs/interchainjs/src/cosmwasm/wasm/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/cosmwasm/wasm/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgStoreCode, MsgInstantiateContract, MsgInstantiateContract2, MsgExecuteContract, MsgMigrateContract, MsgUpdateAdmin, MsgClearAdmin, MsgUpdateInstantiateConfig, MsgUpdateParams, MsgSudoContract, MsgPinCodes, MsgUnpinCodes, MsgStoreAndInstantiateContract, MsgRemoveCodeUploadParamsAddresses, MsgAddCodeUploadParamsAddresses, MsgStoreAndMigrateContract, MsgUpdateContractLabel } from "./tx";
-export const createStoreCode = (getSigningClient: SigningClientResolver) => buildTx<MsgStoreCode>({
-  getSigningClient: getSigningClient,
+export const createStoreCode = (clientResolver: SigningClientResolver) => buildTx<MsgStoreCode>({
+  clientResolver,
   typeUrl: MsgStoreCode.typeUrl,
   encoders: toEncoders(MsgStoreCode),
   converters: toConverters(MsgStoreCode)
@@ -11,8 +11,8 @@ export const createStoreCode = (getSigningClient: SigningClientResolver) => buil
 export const useStoreCode = buildUseMutation<MsgStoreCode, Error>({
   builderMutationFn: createStoreCode
 });
-export const createInstantiateContract = (getSigningClient: SigningClientResolver) => buildTx<MsgInstantiateContract>({
-  getSigningClient: getSigningClient,
+export const createInstantiateContract = (clientResolver: SigningClientResolver) => buildTx<MsgInstantiateContract>({
+  clientResolver,
   typeUrl: MsgInstantiateContract.typeUrl,
   encoders: toEncoders(MsgInstantiateContract),
   converters: toConverters(MsgInstantiateContract)
@@ -20,8 +20,8 @@ export const createInstantiateContract = (getSigningClient: SigningClientResolve
 export const useInstantiateContract = buildUseMutation<MsgInstantiateContract, Error>({
   builderMutationFn: createInstantiateContract
 });
-export const createInstantiateContract2 = (getSigningClient: SigningClientResolver) => buildTx<MsgInstantiateContract2>({
-  getSigningClient: getSigningClient,
+export const createInstantiateContract2 = (clientResolver: SigningClientResolver) => buildTx<MsgInstantiateContract2>({
+  clientResolver,
   typeUrl: MsgInstantiateContract2.typeUrl,
   encoders: toEncoders(MsgInstantiateContract2),
   converters: toConverters(MsgInstantiateContract2)
@@ -29,8 +29,8 @@ export const createInstantiateContract2 = (getSigningClient: SigningClientResolv
 export const useInstantiateContract2 = buildUseMutation<MsgInstantiateContract2, Error>({
   builderMutationFn: createInstantiateContract2
 });
-export const createExecuteContract = (getSigningClient: SigningClientResolver) => buildTx<MsgExecuteContract>({
-  getSigningClient: getSigningClient,
+export const createExecuteContract = (clientResolver: SigningClientResolver) => buildTx<MsgExecuteContract>({
+  clientResolver,
   typeUrl: MsgExecuteContract.typeUrl,
   encoders: toEncoders(MsgExecuteContract),
   converters: toConverters(MsgExecuteContract)
@@ -38,8 +38,8 @@ export const createExecuteContract = (getSigningClient: SigningClientResolver) =
 export const useExecuteContract = buildUseMutation<MsgExecuteContract, Error>({
   builderMutationFn: createExecuteContract
 });
-export const createMigrateContract = (getSigningClient: SigningClientResolver) => buildTx<MsgMigrateContract>({
-  getSigningClient: getSigningClient,
+export const createMigrateContract = (clientResolver: SigningClientResolver) => buildTx<MsgMigrateContract>({
+  clientResolver,
   typeUrl: MsgMigrateContract.typeUrl,
   encoders: toEncoders(MsgMigrateContract),
   converters: toConverters(MsgMigrateContract)
@@ -47,8 +47,8 @@ export const createMigrateContract = (getSigningClient: SigningClientResolver) =
 export const useMigrateContract = buildUseMutation<MsgMigrateContract, Error>({
   builderMutationFn: createMigrateContract
 });
-export const createUpdateAdmin = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateAdmin>({
-  getSigningClient: getSigningClient,
+export const createUpdateAdmin = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateAdmin>({
+  clientResolver,
   typeUrl: MsgUpdateAdmin.typeUrl,
   encoders: toEncoders(MsgUpdateAdmin),
   converters: toConverters(MsgUpdateAdmin)
@@ -56,8 +56,8 @@ export const createUpdateAdmin = (getSigningClient: SigningClientResolver) => bu
 export const useUpdateAdmin = buildUseMutation<MsgUpdateAdmin, Error>({
   builderMutationFn: createUpdateAdmin
 });
-export const createClearAdmin = (getSigningClient: SigningClientResolver) => buildTx<MsgClearAdmin>({
-  getSigningClient: getSigningClient,
+export const createClearAdmin = (clientResolver: SigningClientResolver) => buildTx<MsgClearAdmin>({
+  clientResolver,
   typeUrl: MsgClearAdmin.typeUrl,
   encoders: toEncoders(MsgClearAdmin),
   converters: toConverters(MsgClearAdmin)
@@ -65,8 +65,8 @@ export const createClearAdmin = (getSigningClient: SigningClientResolver) => bui
 export const useClearAdmin = buildUseMutation<MsgClearAdmin, Error>({
   builderMutationFn: createClearAdmin
 });
-export const createUpdateInstantiateConfig = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateInstantiateConfig>({
-  getSigningClient: getSigningClient,
+export const createUpdateInstantiateConfig = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateInstantiateConfig>({
+  clientResolver,
   typeUrl: MsgUpdateInstantiateConfig.typeUrl,
   encoders: toEncoders(MsgUpdateInstantiateConfig),
   converters: toConverters(MsgUpdateInstantiateConfig)
@@ -74,8 +74,8 @@ export const createUpdateInstantiateConfig = (getSigningClient: SigningClientRes
 export const useUpdateInstantiateConfig = buildUseMutation<MsgUpdateInstantiateConfig, Error>({
   builderMutationFn: createUpdateInstantiateConfig
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
@@ -83,8 +83,8 @@ export const createUpdateParams = (getSigningClient: SigningClientResolver) => b
 export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
   builderMutationFn: createUpdateParams
 });
-export const createSudoContract = (getSigningClient: SigningClientResolver) => buildTx<MsgSudoContract>({
-  getSigningClient: getSigningClient,
+export const createSudoContract = (clientResolver: SigningClientResolver) => buildTx<MsgSudoContract>({
+  clientResolver,
   typeUrl: MsgSudoContract.typeUrl,
   encoders: toEncoders(MsgSudoContract),
   converters: toConverters(MsgSudoContract)
@@ -92,8 +92,8 @@ export const createSudoContract = (getSigningClient: SigningClientResolver) => b
 export const useSudoContract = buildUseMutation<MsgSudoContract, Error>({
   builderMutationFn: createSudoContract
 });
-export const createPinCodes = (getSigningClient: SigningClientResolver) => buildTx<MsgPinCodes>({
-  getSigningClient: getSigningClient,
+export const createPinCodes = (clientResolver: SigningClientResolver) => buildTx<MsgPinCodes>({
+  clientResolver,
   typeUrl: MsgPinCodes.typeUrl,
   encoders: toEncoders(MsgPinCodes),
   converters: toConverters(MsgPinCodes)
@@ -101,8 +101,8 @@ export const createPinCodes = (getSigningClient: SigningClientResolver) => build
 export const usePinCodes = buildUseMutation<MsgPinCodes, Error>({
   builderMutationFn: createPinCodes
 });
-export const createUnpinCodes = (getSigningClient: SigningClientResolver) => buildTx<MsgUnpinCodes>({
-  getSigningClient: getSigningClient,
+export const createUnpinCodes = (clientResolver: SigningClientResolver) => buildTx<MsgUnpinCodes>({
+  clientResolver,
   typeUrl: MsgUnpinCodes.typeUrl,
   encoders: toEncoders(MsgUnpinCodes),
   converters: toConverters(MsgUnpinCodes)
@@ -110,8 +110,8 @@ export const createUnpinCodes = (getSigningClient: SigningClientResolver) => bui
 export const useUnpinCodes = buildUseMutation<MsgUnpinCodes, Error>({
   builderMutationFn: createUnpinCodes
 });
-export const createStoreAndInstantiateContract = (getSigningClient: SigningClientResolver) => buildTx<MsgStoreAndInstantiateContract>({
-  getSigningClient: getSigningClient,
+export const createStoreAndInstantiateContract = (clientResolver: SigningClientResolver) => buildTx<MsgStoreAndInstantiateContract>({
+  clientResolver,
   typeUrl: MsgStoreAndInstantiateContract.typeUrl,
   encoders: toEncoders(MsgStoreAndInstantiateContract),
   converters: toConverters(MsgStoreAndInstantiateContract)
@@ -119,8 +119,8 @@ export const createStoreAndInstantiateContract = (getSigningClient: SigningClien
 export const useStoreAndInstantiateContract = buildUseMutation<MsgStoreAndInstantiateContract, Error>({
   builderMutationFn: createStoreAndInstantiateContract
 });
-export const createRemoveCodeUploadParamsAddresses = (getSigningClient: SigningClientResolver) => buildTx<MsgRemoveCodeUploadParamsAddresses>({
-  getSigningClient: getSigningClient,
+export const createRemoveCodeUploadParamsAddresses = (clientResolver: SigningClientResolver) => buildTx<MsgRemoveCodeUploadParamsAddresses>({
+  clientResolver,
   typeUrl: MsgRemoveCodeUploadParamsAddresses.typeUrl,
   encoders: toEncoders(MsgRemoveCodeUploadParamsAddresses),
   converters: toConverters(MsgRemoveCodeUploadParamsAddresses)
@@ -128,8 +128,8 @@ export const createRemoveCodeUploadParamsAddresses = (getSigningClient: SigningC
 export const useRemoveCodeUploadParamsAddresses = buildUseMutation<MsgRemoveCodeUploadParamsAddresses, Error>({
   builderMutationFn: createRemoveCodeUploadParamsAddresses
 });
-export const createAddCodeUploadParamsAddresses = (getSigningClient: SigningClientResolver) => buildTx<MsgAddCodeUploadParamsAddresses>({
-  getSigningClient: getSigningClient,
+export const createAddCodeUploadParamsAddresses = (clientResolver: SigningClientResolver) => buildTx<MsgAddCodeUploadParamsAddresses>({
+  clientResolver,
   typeUrl: MsgAddCodeUploadParamsAddresses.typeUrl,
   encoders: toEncoders(MsgAddCodeUploadParamsAddresses),
   converters: toConverters(MsgAddCodeUploadParamsAddresses)
@@ -137,8 +137,8 @@ export const createAddCodeUploadParamsAddresses = (getSigningClient: SigningClie
 export const useAddCodeUploadParamsAddresses = buildUseMutation<MsgAddCodeUploadParamsAddresses, Error>({
   builderMutationFn: createAddCodeUploadParamsAddresses
 });
-export const createStoreAndMigrateContract = (getSigningClient: SigningClientResolver) => buildTx<MsgStoreAndMigrateContract>({
-  getSigningClient: getSigningClient,
+export const createStoreAndMigrateContract = (clientResolver: SigningClientResolver) => buildTx<MsgStoreAndMigrateContract>({
+  clientResolver,
   typeUrl: MsgStoreAndMigrateContract.typeUrl,
   encoders: toEncoders(MsgStoreAndMigrateContract),
   converters: toConverters(MsgStoreAndMigrateContract)
@@ -146,8 +146,8 @@ export const createStoreAndMigrateContract = (getSigningClient: SigningClientRes
 export const useStoreAndMigrateContract = buildUseMutation<MsgStoreAndMigrateContract, Error>({
   builderMutationFn: createStoreAndMigrateContract
 });
-export const createUpdateContractLabel = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateContractLabel>({
-  getSigningClient: getSigningClient,
+export const createUpdateContractLabel = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateContractLabel>({
+  clientResolver,
   typeUrl: MsgUpdateContractLabel.typeUrl,
   encoders: toEncoders(MsgUpdateContractLabel),
   converters: toConverters(MsgUpdateContractLabel)
diff --git a/libs/interchainjs/src/helper-func-types.ts b/libs/interchainjs/src/helper-func-types.ts
index 73e8c14d..1f99ca9f 100644
--- a/libs/interchainjs/src/helper-func-types.ts
+++ b/libs/interchainjs/src/helper-func-types.ts
@@ -5,29 +5,27 @@
 */
 
 
+import { HttpEndpoint } from "@interchainjs/types";
 import { BinaryReader, BinaryWriter } from "./binary";
 import { getRpcClient } from "./extern";
-import { Rpc } from "./helpers";
+import { isRpc, Rpc } from "./helpers";
 
 export interface QueryBuilderOptions<TReq, TRes> {
   encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter
   decode: (input: BinaryReader | Uint8Array, length?: number) => TRes
   service: string,
   method: string,
-  getRpcInstance: RpcResolver
+  clientResolver: RpcResolver
 }
 
 export function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>) {
     return async (request: TReq) => {
       let rpc: Rpc;
 
-      // if opts.getRpcInstance is a function, call it to get the Rpc instance
-      if(typeof opts.getRpcInstance === 'function') {
-        rpc = await opts.getRpcInstance();
-      } else if(typeof opts.getRpcInstance === 'string') {
-        rpc = await getRpcClient(opts.getRpcInstance);
+      if(isRpc(opts.clientResolver)) {
+        rpc = opts.clientResolver;
       } else {
-        rpc = opts.getRpcInstance;
+        rpc = await getRpcClient(opts.clientResolver);
       }
 
       if (!rpc) throw new Error("Query Rpc is not initialized");
@@ -45,6 +43,13 @@ export interface ITxArgs<TMsg> {
   memo: string;
 }
 
+export function isISigningClient(client: unknown): client is ISigningClient {
+  return typeof (client as ISigningClient).signAndBroadcast === 'function'
+    && typeof (client as ISigningClient).addConverters === 'function'
+    && typeof (client as ISigningClient).addEncoders === 'function';
+
+}
+
 export interface ISigningClient {
   /**
    * register converters
@@ -64,7 +69,7 @@ export interface ISigningClient {
 }
 
 export interface TxBuilderOptions {
-  getSigningClient: SigningClientResolver,
+  clientResolver: SigningClientResolver,
   typeUrl: string,
   encoders?: Encoder[],
   converters?: AminoConverter[],
@@ -80,10 +85,8 @@ export function buildTx<TMsg>(opts: TxBuilderOptions) {
     let client: ISigningClient;
 
     // if opts.getSigningClient is a function, call it to get the SigningClient instance
-    if(typeof opts.getSigningClient === 'function') {
-      client = await opts.getSigningClient();
-    } else {
-      client = opts.getSigningClient;
+    if(isISigningClient(opts.clientResolver)) {
+      client = opts.clientResolver;
     }
 
     if (!client) throw new Error("SigningClient is not initialized");
@@ -184,5 +187,5 @@ export interface AminoConverter {
   toAmino: (data: any) => any;
 }
 
-export type SigningClientResolver = ISigningClient | (() => Promise<ISigningClient> | undefined);
-export type RpcResolver = string | Rpc | (() => Promise<Rpc> | undefined);
+export type SigningClientResolver = string | HttpEndpoint | ISigningClient;
+export type RpcResolver = string | HttpEndpoint | Rpc ;
diff --git a/libs/interchainjs/src/helpers.ts b/libs/interchainjs/src/helpers.ts
index 444da65d..3e1b73d0 100644
--- a/libs/interchainjs/src/helpers.ts
+++ b/libs/interchainjs/src/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/libs/interchainjs/src/ibc/applications/transfer/v1/tx.rpc.func.ts b/libs/interchainjs/src/ibc/applications/transfer/v1/tx.rpc.func.ts
index 83fd5f9f..e58ab5d7 100644
--- a/libs/interchainjs/src/ibc/applications/transfer/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/ibc/applications/transfer/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
 import { buildUseMutation } from "../../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgTransfer, MsgUpdateParams } from "./tx";
-export const createTransfer = (getSigningClient: SigningClientResolver) => buildTx<MsgTransfer>({
-  getSigningClient: getSigningClient,
+export const createTransfer = (clientResolver: SigningClientResolver) => buildTx<MsgTransfer>({
+  clientResolver,
   typeUrl: MsgTransfer.typeUrl,
   encoders: toEncoders(MsgTransfer),
   converters: toConverters(MsgTransfer)
@@ -11,8 +11,8 @@ export const createTransfer = (getSigningClient: SigningClientResolver) => build
 export const useTransfer = buildUseMutation<MsgTransfer, Error>({
   builderMutationFn: createTransfer
 });
-export const createUpdateParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
diff --git a/libs/interchainjs/src/ibc/core/channel/v1/tx.rpc.func.ts b/libs/interchainjs/src/ibc/core/channel/v1/tx.rpc.func.ts
index b3f4159e..af55efe1 100644
--- a/libs/interchainjs/src/ibc/core/channel/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/ibc/core/channel/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
 import { buildUseMutation } from "../../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement, MsgChannelUpgradeInit, MsgChannelUpgradeTry, MsgChannelUpgradeAck, MsgChannelUpgradeConfirm, MsgChannelUpgradeOpen, MsgChannelUpgradeTimeout, MsgChannelUpgradeCancel, MsgUpdateParams, MsgPruneAcknowledgements } from "./tx";
-export const createChannelOpenInit = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelOpenInit>({
-  getSigningClient: getSigningClient,
+export const createChannelOpenInit = (clientResolver: SigningClientResolver) => buildTx<MsgChannelOpenInit>({
+  clientResolver,
   typeUrl: MsgChannelOpenInit.typeUrl,
   encoders: toEncoders(MsgChannelOpenInit),
   converters: toConverters(MsgChannelOpenInit)
@@ -11,8 +11,8 @@ export const createChannelOpenInit = (getSigningClient: SigningClientResolver) =
 export const useChannelOpenInit = buildUseMutation<MsgChannelOpenInit, Error>({
   builderMutationFn: createChannelOpenInit
 });
-export const createChannelOpenTry = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelOpenTry>({
-  getSigningClient: getSigningClient,
+export const createChannelOpenTry = (clientResolver: SigningClientResolver) => buildTx<MsgChannelOpenTry>({
+  clientResolver,
   typeUrl: MsgChannelOpenTry.typeUrl,
   encoders: toEncoders(MsgChannelOpenTry),
   converters: toConverters(MsgChannelOpenTry)
@@ -20,8 +20,8 @@ export const createChannelOpenTry = (getSigningClient: SigningClientResolver) =>
 export const useChannelOpenTry = buildUseMutation<MsgChannelOpenTry, Error>({
   builderMutationFn: createChannelOpenTry
 });
-export const createChannelOpenAck = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelOpenAck>({
-  getSigningClient: getSigningClient,
+export const createChannelOpenAck = (clientResolver: SigningClientResolver) => buildTx<MsgChannelOpenAck>({
+  clientResolver,
   typeUrl: MsgChannelOpenAck.typeUrl,
   encoders: toEncoders(MsgChannelOpenAck),
   converters: toConverters(MsgChannelOpenAck)
@@ -29,8 +29,8 @@ export const createChannelOpenAck = (getSigningClient: SigningClientResolver) =>
 export const useChannelOpenAck = buildUseMutation<MsgChannelOpenAck, Error>({
   builderMutationFn: createChannelOpenAck
 });
-export const createChannelOpenConfirm = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelOpenConfirm>({
-  getSigningClient: getSigningClient,
+export const createChannelOpenConfirm = (clientResolver: SigningClientResolver) => buildTx<MsgChannelOpenConfirm>({
+  clientResolver,
   typeUrl: MsgChannelOpenConfirm.typeUrl,
   encoders: toEncoders(MsgChannelOpenConfirm),
   converters: toConverters(MsgChannelOpenConfirm)
@@ -38,8 +38,8 @@ export const createChannelOpenConfirm = (getSigningClient: SigningClientResolver
 export const useChannelOpenConfirm = buildUseMutation<MsgChannelOpenConfirm, Error>({
   builderMutationFn: createChannelOpenConfirm
 });
-export const createChannelCloseInit = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelCloseInit>({
-  getSigningClient: getSigningClient,
+export const createChannelCloseInit = (clientResolver: SigningClientResolver) => buildTx<MsgChannelCloseInit>({
+  clientResolver,
   typeUrl: MsgChannelCloseInit.typeUrl,
   encoders: toEncoders(MsgChannelCloseInit),
   converters: toConverters(MsgChannelCloseInit)
@@ -47,8 +47,8 @@ export const createChannelCloseInit = (getSigningClient: SigningClientResolver)
 export const useChannelCloseInit = buildUseMutation<MsgChannelCloseInit, Error>({
   builderMutationFn: createChannelCloseInit
 });
-export const createChannelCloseConfirm = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelCloseConfirm>({
-  getSigningClient: getSigningClient,
+export const createChannelCloseConfirm = (clientResolver: SigningClientResolver) => buildTx<MsgChannelCloseConfirm>({
+  clientResolver,
   typeUrl: MsgChannelCloseConfirm.typeUrl,
   encoders: toEncoders(MsgChannelCloseConfirm),
   converters: toConverters(MsgChannelCloseConfirm)
@@ -56,8 +56,8 @@ export const createChannelCloseConfirm = (getSigningClient: SigningClientResolve
 export const useChannelCloseConfirm = buildUseMutation<MsgChannelCloseConfirm, Error>({
   builderMutationFn: createChannelCloseConfirm
 });
-export const createRecvPacket = (getSigningClient: SigningClientResolver) => buildTx<MsgRecvPacket>({
-  getSigningClient: getSigningClient,
+export const createRecvPacket = (clientResolver: SigningClientResolver) => buildTx<MsgRecvPacket>({
+  clientResolver,
   typeUrl: MsgRecvPacket.typeUrl,
   encoders: toEncoders(MsgRecvPacket),
   converters: toConverters(MsgRecvPacket)
@@ -65,8 +65,8 @@ export const createRecvPacket = (getSigningClient: SigningClientResolver) => bui
 export const useRecvPacket = buildUseMutation<MsgRecvPacket, Error>({
   builderMutationFn: createRecvPacket
 });
-export const createTimeout = (getSigningClient: SigningClientResolver) => buildTx<MsgTimeout>({
-  getSigningClient: getSigningClient,
+export const createTimeout = (clientResolver: SigningClientResolver) => buildTx<MsgTimeout>({
+  clientResolver,
   typeUrl: MsgTimeout.typeUrl,
   encoders: toEncoders(MsgTimeout),
   converters: toConverters(MsgTimeout)
@@ -74,8 +74,8 @@ export const createTimeout = (getSigningClient: SigningClientResolver) => buildT
 export const useTimeout = buildUseMutation<MsgTimeout, Error>({
   builderMutationFn: createTimeout
 });
-export const createTimeoutOnClose = (getSigningClient: SigningClientResolver) => buildTx<MsgTimeoutOnClose>({
-  getSigningClient: getSigningClient,
+export const createTimeoutOnClose = (clientResolver: SigningClientResolver) => buildTx<MsgTimeoutOnClose>({
+  clientResolver,
   typeUrl: MsgTimeoutOnClose.typeUrl,
   encoders: toEncoders(MsgTimeoutOnClose),
   converters: toConverters(MsgTimeoutOnClose)
@@ -83,8 +83,8 @@ export const createTimeoutOnClose = (getSigningClient: SigningClientResolver) =>
 export const useTimeoutOnClose = buildUseMutation<MsgTimeoutOnClose, Error>({
   builderMutationFn: createTimeoutOnClose
 });
-export const createAcknowledgement = (getSigningClient: SigningClientResolver) => buildTx<MsgAcknowledgement>({
-  getSigningClient: getSigningClient,
+export const createAcknowledgement = (clientResolver: SigningClientResolver) => buildTx<MsgAcknowledgement>({
+  clientResolver,
   typeUrl: MsgAcknowledgement.typeUrl,
   encoders: toEncoders(MsgAcknowledgement),
   converters: toConverters(MsgAcknowledgement)
@@ -92,8 +92,8 @@ export const createAcknowledgement = (getSigningClient: SigningClientResolver) =
 export const useAcknowledgement = buildUseMutation<MsgAcknowledgement, Error>({
   builderMutationFn: createAcknowledgement
 });
-export const createChannelUpgradeInit = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeInit>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeInit = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeInit>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeInit.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeInit),
   converters: toConverters(MsgChannelUpgradeInit)
@@ -101,8 +101,8 @@ export const createChannelUpgradeInit = (getSigningClient: SigningClientResolver
 export const useChannelUpgradeInit = buildUseMutation<MsgChannelUpgradeInit, Error>({
   builderMutationFn: createChannelUpgradeInit
 });
-export const createChannelUpgradeTry = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeTry>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeTry = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeTry>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeTry.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeTry),
   converters: toConverters(MsgChannelUpgradeTry)
@@ -110,8 +110,8 @@ export const createChannelUpgradeTry = (getSigningClient: SigningClientResolver)
 export const useChannelUpgradeTry = buildUseMutation<MsgChannelUpgradeTry, Error>({
   builderMutationFn: createChannelUpgradeTry
 });
-export const createChannelUpgradeAck = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeAck>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeAck = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeAck>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeAck.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeAck),
   converters: toConverters(MsgChannelUpgradeAck)
@@ -119,8 +119,8 @@ export const createChannelUpgradeAck = (getSigningClient: SigningClientResolver)
 export const useChannelUpgradeAck = buildUseMutation<MsgChannelUpgradeAck, Error>({
   builderMutationFn: createChannelUpgradeAck
 });
-export const createChannelUpgradeConfirm = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeConfirm>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeConfirm = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeConfirm>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeConfirm.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeConfirm),
   converters: toConverters(MsgChannelUpgradeConfirm)
@@ -128,8 +128,8 @@ export const createChannelUpgradeConfirm = (getSigningClient: SigningClientResol
 export const useChannelUpgradeConfirm = buildUseMutation<MsgChannelUpgradeConfirm, Error>({
   builderMutationFn: createChannelUpgradeConfirm
 });
-export const createChannelUpgradeOpen = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeOpen>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeOpen = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeOpen>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeOpen.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeOpen),
   converters: toConverters(MsgChannelUpgradeOpen)
@@ -137,8 +137,8 @@ export const createChannelUpgradeOpen = (getSigningClient: SigningClientResolver
 export const useChannelUpgradeOpen = buildUseMutation<MsgChannelUpgradeOpen, Error>({
   builderMutationFn: createChannelUpgradeOpen
 });
-export const createChannelUpgradeTimeout = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeTimeout>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeTimeout = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeTimeout>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeTimeout.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeTimeout),
   converters: toConverters(MsgChannelUpgradeTimeout)
@@ -146,8 +146,8 @@ export const createChannelUpgradeTimeout = (getSigningClient: SigningClientResol
 export const useChannelUpgradeTimeout = buildUseMutation<MsgChannelUpgradeTimeout, Error>({
   builderMutationFn: createChannelUpgradeTimeout
 });
-export const createChannelUpgradeCancel = (getSigningClient: SigningClientResolver) => buildTx<MsgChannelUpgradeCancel>({
-  getSigningClient: getSigningClient,
+export const createChannelUpgradeCancel = (clientResolver: SigningClientResolver) => buildTx<MsgChannelUpgradeCancel>({
+  clientResolver,
   typeUrl: MsgChannelUpgradeCancel.typeUrl,
   encoders: toEncoders(MsgChannelUpgradeCancel),
   converters: toConverters(MsgChannelUpgradeCancel)
@@ -155,8 +155,8 @@ export const createChannelUpgradeCancel = (getSigningClient: SigningClientResolv
 export const useChannelUpgradeCancel = buildUseMutation<MsgChannelUpgradeCancel, Error>({
   builderMutationFn: createChannelUpgradeCancel
 });
-export const createUpdateChannelParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateChannelParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
@@ -164,8 +164,8 @@ export const createUpdateChannelParams = (getSigningClient: SigningClientResolve
 export const useUpdateChannelParams = buildUseMutation<MsgUpdateParams, Error>({
   builderMutationFn: createUpdateChannelParams
 });
-export const createPruneAcknowledgements = (getSigningClient: SigningClientResolver) => buildTx<MsgPruneAcknowledgements>({
-  getSigningClient: getSigningClient,
+export const createPruneAcknowledgements = (clientResolver: SigningClientResolver) => buildTx<MsgPruneAcknowledgements>({
+  clientResolver,
   typeUrl: MsgPruneAcknowledgements.typeUrl,
   encoders: toEncoders(MsgPruneAcknowledgements),
   converters: toConverters(MsgPruneAcknowledgements)
diff --git a/libs/interchainjs/src/ibc/core/client/v1/tx.rpc.func.ts b/libs/interchainjs/src/ibc/core/client/v1/tx.rpc.func.ts
index d89cd9fd..778f739e 100644
--- a/libs/interchainjs/src/ibc/core/client/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/ibc/core/client/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
 import { buildUseMutation } from "../../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateClient, MsgUpdateClient, MsgUpgradeClient, MsgSubmitMisbehaviour, MsgRecoverClient, MsgIBCSoftwareUpgrade, MsgUpdateParams } from "./tx";
-export const createCreateClient = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateClient>({
-  getSigningClient: getSigningClient,
+export const createCreateClient = (clientResolver: SigningClientResolver) => buildTx<MsgCreateClient>({
+  clientResolver,
   typeUrl: MsgCreateClient.typeUrl,
   encoders: toEncoders(MsgCreateClient),
   converters: toConverters(MsgCreateClient)
@@ -11,8 +11,8 @@ export const createCreateClient = (getSigningClient: SigningClientResolver) => b
 export const useCreateClient = buildUseMutation<MsgCreateClient, Error>({
   builderMutationFn: createCreateClient
 });
-export const createUpdateClient = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateClient>({
-  getSigningClient: getSigningClient,
+export const createUpdateClient = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateClient>({
+  clientResolver,
   typeUrl: MsgUpdateClient.typeUrl,
   encoders: toEncoders(MsgUpdateClient),
   converters: toConverters(MsgUpdateClient)
@@ -20,8 +20,8 @@ export const createUpdateClient = (getSigningClient: SigningClientResolver) => b
 export const useUpdateClient = buildUseMutation<MsgUpdateClient, Error>({
   builderMutationFn: createUpdateClient
 });
-export const createUpgradeClient = (getSigningClient: SigningClientResolver) => buildTx<MsgUpgradeClient>({
-  getSigningClient: getSigningClient,
+export const createUpgradeClient = (clientResolver: SigningClientResolver) => buildTx<MsgUpgradeClient>({
+  clientResolver,
   typeUrl: MsgUpgradeClient.typeUrl,
   encoders: toEncoders(MsgUpgradeClient),
   converters: toConverters(MsgUpgradeClient)
@@ -29,8 +29,8 @@ export const createUpgradeClient = (getSigningClient: SigningClientResolver) =>
 export const useUpgradeClient = buildUseMutation<MsgUpgradeClient, Error>({
   builderMutationFn: createUpgradeClient
 });
-export const createSubmitMisbehaviour = (getSigningClient: SigningClientResolver) => buildTx<MsgSubmitMisbehaviour>({
-  getSigningClient: getSigningClient,
+export const createSubmitMisbehaviour = (clientResolver: SigningClientResolver) => buildTx<MsgSubmitMisbehaviour>({
+  clientResolver,
   typeUrl: MsgSubmitMisbehaviour.typeUrl,
   encoders: toEncoders(MsgSubmitMisbehaviour),
   converters: toConverters(MsgSubmitMisbehaviour)
@@ -38,8 +38,8 @@ export const createSubmitMisbehaviour = (getSigningClient: SigningClientResolver
 export const useSubmitMisbehaviour = buildUseMutation<MsgSubmitMisbehaviour, Error>({
   builderMutationFn: createSubmitMisbehaviour
 });
-export const createRecoverClient = (getSigningClient: SigningClientResolver) => buildTx<MsgRecoverClient>({
-  getSigningClient: getSigningClient,
+export const createRecoverClient = (clientResolver: SigningClientResolver) => buildTx<MsgRecoverClient>({
+  clientResolver,
   typeUrl: MsgRecoverClient.typeUrl,
   encoders: toEncoders(MsgRecoverClient),
   converters: toConverters(MsgRecoverClient)
@@ -47,8 +47,8 @@ export const createRecoverClient = (getSigningClient: SigningClientResolver) =>
 export const useRecoverClient = buildUseMutation<MsgRecoverClient, Error>({
   builderMutationFn: createRecoverClient
 });
-export const createIBCSoftwareUpgrade = (getSigningClient: SigningClientResolver) => buildTx<MsgIBCSoftwareUpgrade>({
-  getSigningClient: getSigningClient,
+export const createIBCSoftwareUpgrade = (clientResolver: SigningClientResolver) => buildTx<MsgIBCSoftwareUpgrade>({
+  clientResolver,
   typeUrl: MsgIBCSoftwareUpgrade.typeUrl,
   encoders: toEncoders(MsgIBCSoftwareUpgrade),
   converters: toConverters(MsgIBCSoftwareUpgrade)
@@ -56,8 +56,8 @@ export const createIBCSoftwareUpgrade = (getSigningClient: SigningClientResolver
 export const useIBCSoftwareUpgrade = buildUseMutation<MsgIBCSoftwareUpgrade, Error>({
   builderMutationFn: createIBCSoftwareUpgrade
 });
-export const createUpdateClientParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateClientParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
diff --git a/libs/interchainjs/src/ibc/core/connection/v1/tx.rpc.func.ts b/libs/interchainjs/src/ibc/core/connection/v1/tx.rpc.func.ts
index f6bbaa03..fb9ff7ad 100644
--- a/libs/interchainjs/src/ibc/core/connection/v1/tx.rpc.func.ts
+++ b/libs/interchainjs/src/ibc/core/connection/v1/tx.rpc.func.ts
@@ -2,8 +2,8 @@ import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
 import { buildUseMutation } from "../../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgConnectionOpenInit, MsgConnectionOpenTry, MsgConnectionOpenAck, MsgConnectionOpenConfirm, MsgUpdateParams } from "./tx";
-export const createConnectionOpenInit = (getSigningClient: SigningClientResolver) => buildTx<MsgConnectionOpenInit>({
-  getSigningClient: getSigningClient,
+export const createConnectionOpenInit = (clientResolver: SigningClientResolver) => buildTx<MsgConnectionOpenInit>({
+  clientResolver,
   typeUrl: MsgConnectionOpenInit.typeUrl,
   encoders: toEncoders(MsgConnectionOpenInit),
   converters: toConverters(MsgConnectionOpenInit)
@@ -11,8 +11,8 @@ export const createConnectionOpenInit = (getSigningClient: SigningClientResolver
 export const useConnectionOpenInit = buildUseMutation<MsgConnectionOpenInit, Error>({
   builderMutationFn: createConnectionOpenInit
 });
-export const createConnectionOpenTry = (getSigningClient: SigningClientResolver) => buildTx<MsgConnectionOpenTry>({
-  getSigningClient: getSigningClient,
+export const createConnectionOpenTry = (clientResolver: SigningClientResolver) => buildTx<MsgConnectionOpenTry>({
+  clientResolver,
   typeUrl: MsgConnectionOpenTry.typeUrl,
   encoders: toEncoders(MsgConnectionOpenTry),
   converters: toConverters(MsgConnectionOpenTry)
@@ -20,8 +20,8 @@ export const createConnectionOpenTry = (getSigningClient: SigningClientResolver)
 export const useConnectionOpenTry = buildUseMutation<MsgConnectionOpenTry, Error>({
   builderMutationFn: createConnectionOpenTry
 });
-export const createConnectionOpenAck = (getSigningClient: SigningClientResolver) => buildTx<MsgConnectionOpenAck>({
-  getSigningClient: getSigningClient,
+export const createConnectionOpenAck = (clientResolver: SigningClientResolver) => buildTx<MsgConnectionOpenAck>({
+  clientResolver,
   typeUrl: MsgConnectionOpenAck.typeUrl,
   encoders: toEncoders(MsgConnectionOpenAck),
   converters: toConverters(MsgConnectionOpenAck)
@@ -29,8 +29,8 @@ export const createConnectionOpenAck = (getSigningClient: SigningClientResolver)
 export const useConnectionOpenAck = buildUseMutation<MsgConnectionOpenAck, Error>({
   builderMutationFn: createConnectionOpenAck
 });
-export const createConnectionOpenConfirm = (getSigningClient: SigningClientResolver) => buildTx<MsgConnectionOpenConfirm>({
-  getSigningClient: getSigningClient,
+export const createConnectionOpenConfirm = (clientResolver: SigningClientResolver) => buildTx<MsgConnectionOpenConfirm>({
+  clientResolver,
   typeUrl: MsgConnectionOpenConfirm.typeUrl,
   encoders: toEncoders(MsgConnectionOpenConfirm),
   converters: toConverters(MsgConnectionOpenConfirm)
@@ -38,8 +38,8 @@ export const createConnectionOpenConfirm = (getSigningClient: SigningClientResol
 export const useConnectionOpenConfirm = buildUseMutation<MsgConnectionOpenConfirm, Error>({
   builderMutationFn: createConnectionOpenConfirm
 });
-export const createUpdateConnectionParams = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateParams>({
-  getSigningClient: getSigningClient,
+export const createUpdateConnectionParams = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
   typeUrl: MsgUpdateParams.typeUrl,
   encoders: toEncoders(MsgUpdateParams),
   converters: toConverters(MsgUpdateParams)
diff --git a/libs/interchainjs/src/react-query.ts b/libs/interchainjs/src/react-query.ts
index 31cca878..9574a5fe 100644
--- a/libs/interchainjs/src/react-query.ts
+++ b/libs/interchainjs/src/react-query.ts
@@ -6,6 +6,7 @@
 
 import { getRpcClient } from './extern'
 import {
+  isRpc,
   Rpc,
 } from './helpers'
 import {
@@ -14,7 +15,8 @@ import {
   StdFee,
   DeliverTxResponse,
   SigningClientResolver,
-  RpcResolver
+  RpcResolver,
+  isISigningClient
 } from './helper-func-types'
 import {
     useQuery,
@@ -33,13 +35,21 @@ export const DEFAULT_RPC_CLIENT_QUERY_KEY = 'rpcClient';
 export const DEFAULT_RPC_ENDPOINT_QUERY_KEY = 'rpcEndPoint';
 export const DEFAULT_SIGNING_CLIENT_QUERY_KEY = 'signingClient';
 
+export interface CacheResolver {
+    rpcEndpoint?: string | HttpEndpoint;
+    clientQueryKey?: string;
+}
+
+export function isCacheResolver(resolver: unknown) : resolver is CacheResolver {
+    return (resolver as CacheResolver).rpcEndpoint !== undefined && (resolver as CacheResolver).clientQueryKey !== undefined;
+}
+
 export interface ReactQueryParams<TResponse, TData = TResponse> {
     options?: UseQueryOptions<TResponse, Error, TData>;
-    rpcEndpoint?: string | HttpEndpoint;
-    rpcClientQueryKey?: string;
 }
 
 export interface UseRpcClientQuery<TData> extends ReactQueryParams<ProtobufRpcClient, TData> {
+    clientResolver?: CacheResolver;
 }
 
 export interface UseRpcEndpointQuery<TData> extends ReactQueryParams<string | HttpEndpoint, TData> {
@@ -59,20 +69,20 @@ export const useRpcEndpoint = <TData = string | HttpEndpoint>({
 };
 
 export const useRpcClient = <TData = ProtobufRpcClient>({
-    rpcEndpoint,
     options,
-    rpcClientQueryKey,
+    clientResolver
 }: UseRpcClientQuery<TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-    return useQuery<ProtobufRpcClient, Error, TData>([key, rpcEndpoint], async () => {
-      if(!rpcEndpoint) {
+
+    const key = clientResolver.clientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
+    return useQuery<ProtobufRpcClient, Error, TData>([key, clientResolver.rpcEndpoint], async () => {
+      if(!clientResolver.rpcEndpoint) {
         throw new Error('rpcEndpoint is required');
       }
 
-      const client = await getRpcClient(rpcEndpoint);
+      const client = await getRpcClient(clientResolver.rpcEndpoint);
       if(!client) {
           throw new Error('Failed to connect to rpc client');
       }
@@ -84,7 +94,7 @@ export const useRpcClient = <TData = ProtobufRpcClient>({
 };
 
 export interface UseQueryBuilderOptions<TReq, TRes> {
-  builderQueryFn: (getRpcInstance: RpcResolver) => (request: TReq) => Promise<TRes>,
+  builderQueryFn: (clientResolver: RpcResolver) => (request: TReq) => Promise<TRes>,
   queryKeyPrefix: string,
 }
 
@@ -93,10 +103,8 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
   return <TData = TRes>({
     request,
     options,
-    rpcEndpoint,
-    rpcClientQueryKey,
+    clientResolver,
     customizedQueryKey,
-    getRpcInstance,
   }: UseQueryParams<TReq, TRes, TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
@@ -104,16 +112,18 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
 
     let rpcResolver: RpcResolver;
 
-    if(!getRpcInstance) {
-      if(rpcEndpoint && typeof rpcEndpoint === 'string') {
-        rpcResolver = rpcEndpoint;
-      } else {
-        const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-        const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [key];
-        rpcResolver = queryClient.getQueryData<Rpc>(queryKey);
+    if(isRpc(clientResolver)) {
+      rpcResolver = clientResolver;
+    } else if(isCacheResolver(clientResolver)) {
+      const key = clientResolver.clientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
+      const queryKey = clientResolver.rpcEndpoint ? [key, clientResolver.rpcEndpoint] : [key];
+      rpcResolver = queryClient.getQueryData<Rpc>(queryKey);
+
+      if(!rpcResolver && clientResolver.rpcEndpoint) {
+        rpcResolver = clientResolver.rpcEndpoint;
       }
     } else {
-      rpcResolver = getRpcInstance;
+      rpcResolver = clientResolver;
     }
 
     const queryFn = opts.builderQueryFn(rpcResolver);
@@ -123,15 +133,13 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
 
 export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
   request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
   customizedQueryKey?: QueryKey
-  getRpcInstance?: RpcResolver;
 }
 
 export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
   options?: UseMutationOptions<TData, TError, TVariables, TContext>;
-  rpcEndpoint?: string | HttpEndpoint;
-  signingClientQueryKey?: string;
-  getSingingClient?: SigningClientResolver;
+  clientResolver?: CacheResolver | SigningClientResolver;
 }
 
 
@@ -148,9 +156,7 @@ export interface UseMutationBuilderOptions<TMsg> {
 export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
   return ({
     options,
-    rpcEndpoint,
-    signingClientQueryKey,
-    getSingingClient,
+    clientResolver
   }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
     const queryClient = useQueryClient({
       context: options?.context
@@ -158,12 +164,14 @@ export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<T
 
     let signingClientResolver: SigningClientResolver;
 
-    if(!getSingingClient) {
-      const key = signingClientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
-      const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [DEFAULT_SIGNING_CLIENT_QUERY_KEY];
+    if(isISigningClient(clientResolver)) {
+      signingClientResolver = clientResolver;
+    } else if(isCacheResolver(clientResolver)) {
+      const key = clientResolver.clientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
+      const queryKey = clientResolver.rpcEndpoint ? [key, clientResolver.rpcEndpoint] : [key];
       signingClientResolver = queryClient.getQueryData<ISigningClient>(queryKey);
     } else {
-      signingClientResolver = getSingingClient;
+      clientResolver = clientResolver;
     }
 
     const mutationFn = opts.builderMutationFn(signingClientResolver);
diff --git a/packages/types/src/signer.ts b/packages/types/src/signer.ts
index 1b22c83b..b7ccc0ed 100644
--- a/packages/types/src/signer.ts
+++ b/packages/types/src/signer.ts
@@ -11,6 +11,14 @@ export interface HttpEndpoint {
   headers: Record<string, string>;
 }
 
+export function isHttpEndpoint(endpoint: unknown): endpoint is HttpEndpoint {
+
+  return (
+    typeof (endpoint as HttpEndpoint).url === 'string' &&
+    typeof (endpoint as HttpEndpoint).headers === 'object'
+  );
+}
+
 export interface Price {
   amount: Decimal;
   denom: string;