diff --git a/__fixtures__/misc/enforce-null-check-true/helpers.ts b/__fixtures__/misc/enforce-null-check-true/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/enforce-null-check-true/helpers.ts
+++ b/__fixtures__/misc/enforce-null-check-true/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-base64/helpers.ts b/__fixtures__/misc/output-base64/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-base64/helpers.ts
+++ b/__fixtures__/misc/output-base64/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-decimals/helpers.ts b/__fixtures__/misc/output-decimals/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-decimals/helpers.ts
+++ b/__fixtures__/misc/output-decimals/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-impl-interfaces-gen/helpers.ts b/__fixtures__/misc/output-impl-interfaces-gen/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-impl-interfaces-gen/helpers.ts
+++ b/__fixtures__/misc/output-impl-interfaces-gen/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-interface-proto-optionality/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-interface-proto-optionality/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/amino-interface-proto-optionality/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-interface-proto-optionality/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-interface/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-interface/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/amino-interface/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-interface/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-legacy/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-legacy/helpers.ts
index cde3e8ad2..07fccf9e2 100644
--- a/__fixtures__/misc/output-proto-amino/amino-legacy/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-legacy/helpers.ts
@@ -200,6 +200,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-msg-no-func/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-msg-no-func/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/amino-msg-no-func/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-msg-no-func/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-msg-with-func/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-msg-with-func/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/amino-msg-with-func/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-msg-with-func/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/amino-no-msg-with-func/helpers.ts b/__fixtures__/misc/output-proto-amino/amino-no-msg-with-func/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/amino-no-msg-with-func/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/amino-no-msg-with-func/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/no-amino-legacy-no-proto/helpers.ts b/__fixtures__/misc/output-proto-amino/no-amino-legacy-no-proto/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/no-amino-legacy-no-proto/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/no-amino-legacy-no-proto/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/no-amino-legacy/helpers.ts b/__fixtures__/misc/output-proto-amino/no-amino-legacy/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/no-amino-legacy/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/no-amino-legacy/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/no-amino-no-proto/helpers.ts b/__fixtures__/misc/output-proto-amino/no-amino-no-proto/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/no-amino-no-proto/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/no-amino-no-proto/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/no-amino/helpers.ts b/__fixtures__/misc/output-proto-amino/no-amino/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/no-amino/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/no-amino/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/proto-only-legacy/helpers.ts b/__fixtures__/misc/output-proto-amino/proto-only-legacy/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/proto-only-legacy/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/proto-only-legacy/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-proto-amino/proto-only/helpers.ts b/__fixtures__/misc/output-proto-amino/proto-only/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-proto-amino/proto-only/helpers.ts
+++ b/__fixtures__/misc/output-proto-amino/proto-only/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output-scalar-default-nullable-true/helpers.ts b/__fixtures__/misc/output-scalar-default-nullable-true/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output-scalar-default-nullable-true/helpers.ts
+++ b/__fixtures__/misc/output-scalar-default-nullable-true/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/misc/output/helpers.ts b/__fixtures__/misc/output/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/misc/output/helpers.ts
+++ b/__fixtures__/misc/output/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputhelperfunc/cosmos/bank/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputhelperfunc/cosmos/bank/v1beta1/tx.rpc.func.ts
index ce32a5bd1..34024ade6 100644
--- a/__fixtures__/v-next/outputhelperfunc/cosmos/bank/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputhelperfunc/cosmos/bank/v1beta1/tx.rpc.func.ts
@@ -4,8 +4,8 @@ import { buildTx, ISigningClient, SigningClientResolver } from "../../../helper-
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSend, MsgSendSDKType, MsgSendResponse, MsgSendResponseSDKType, MsgMultiSend, MsgMultiSendSDKType, MsgMultiSendResponse, MsgMultiSendResponseSDKType } from "./tx";
-export const createSend = (getSigningClient: SigningClientResolver) => buildTx<MsgSend>({
-  getSigningClient: getSigningClient,
+export const createSend = (clientResolver: SigningClientResolver) => buildTx<MsgSend>({
+  clientResolver,
   typeUrl: MsgSend.typeUrl,
   encoders: toEncoders(MsgSend),
   converters: toConverters(MsgSend)
@@ -13,8 +13,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)
diff --git a/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/query.rpc.func.ts
index 679cda906..bd25554ac 100644
--- a/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/query.rpc.func.ts
@@ -3,89 +3,89 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryProposalRequest, QueryProposalRequestSDKType, QueryProposalResponse, QueryProposalResponseSDKType, QueryProposalsRequest, QueryProposalsRequestSDKType, QueryProposalsResponse, QueryProposalsResponseSDKType, QueryVoteRequest, QueryVoteRequestSDKType, QueryVoteResponse, QueryVoteResponseSDKType, QueryVotesRequest, QueryVotesRequestSDKType, QueryVotesResponse, QueryVotesResponseSDKType, QueryParamsRequest, QueryParamsRequestSDKType, QueryParamsResponse, QueryParamsResponseSDKType, QueryDepositRequest, QueryDepositRequestSDKType, QueryDepositResponse, QueryDepositResponseSDKType, QueryDepositsRequest, QueryDepositsRequestSDKType, QueryDepositsResponse, QueryDepositsResponseSDKType, QueryTallyResultRequest, QueryTallyResultRequestSDKType, QueryTallyResultResponse, QueryTallyResultResponseSDKType } 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 buildHelperVote = (getRpcInstance: RpcResolver) => buildQuery<QueryVoteRequest, QueryVoteResponse>({
+export const buildHelperVote = (clientResolver: RpcResolver) => buildQuery<QueryVoteRequest, QueryVoteResponse>({
   encode: QueryVoteRequest.encode,
   decode: QueryVoteResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Vote",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useHelperVote = buildUseQuery<QueryVoteRequest, QueryVoteResponse>({
   builderQueryFn: buildHelperVote,
   queryKeyPrefix: "VoteQuery"
 });
-export const buildHelperVotes = (getRpcInstance: RpcResolver) => buildQuery<QueryVotesRequest, QueryVotesResponse>({
+export const buildHelperVotes = (clientResolver: RpcResolver) => buildQuery<QueryVotesRequest, QueryVotesResponse>({
   encode: QueryVotesRequest.encode,
   decode: QueryVotesResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Votes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useHelperVotes = buildUseQuery<QueryVotesRequest, QueryVotesResponse>({
   builderQueryFn: buildHelperVotes,
   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 createCheckDeposit = (getRpcInstance: RpcResolver) => buildQuery<QueryDepositRequest, QueryDepositResponse>({
+export const createCheckDeposit = (clientResolver: RpcResolver) => buildQuery<QueryDepositRequest, QueryDepositResponse>({
   encode: QueryDepositRequest.encode,
   decode: QueryDepositResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Deposit",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useCheckDeposit = buildUseQuery<QueryDepositRequest, QueryDepositResponse>({
   builderQueryFn: createCheckDeposit,
   queryKeyPrefix: "DepositQuery"
 });
-export const createGoOverDeposits = (getRpcInstance: RpcResolver) => buildQuery<QueryDepositsRequest, QueryDepositsResponse>({
+export const createGoOverDeposits = (clientResolver: RpcResolver) => buildQuery<QueryDepositsRequest, QueryDepositsResponse>({
   encode: QueryDepositsRequest.encode,
   decode: QueryDepositsResponse.decode,
   service: "cosmos.gov.v1beta1.Query",
   method: "Deposits",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGoOverDeposits = buildUseQuery<QueryDepositsRequest, QueryDepositsResponse>({
   builderQueryFn: createGoOverDeposits,
   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/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/tx.rpc.func.ts
index f26c0d02a..da68273a4 100644
--- a/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputhelperfunc/cosmos/gov/v1beta1/tx.rpc.func.ts
@@ -5,8 +5,8 @@ import { buildTx, ISigningClient, SigningClientResolver } from "../../../helper-
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgSubmitProposal, MsgSubmitProposalSDKType, MsgSubmitProposalResponse, MsgSubmitProposalResponseSDKType, MsgVote, MsgVoteSDKType, MsgVoteResponse, MsgVoteResponseSDKType, MsgVoteWeighted, MsgVoteWeightedSDKType, MsgVoteWeightedResponse, MsgVoteWeightedResponseSDKType, MsgDeposit, MsgDepositSDKType, MsgDepositResponse, MsgDepositResponseSDKType } 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)
@@ -14,8 +14,8 @@ export const createSubmitProposal = (getSigningClient: SigningClientResolver) =>
 export const useSubmitProposal = buildUseMutation<MsgSubmitProposal, Error>({
   builderMutationFn: createSubmitProposal
 });
-export const buildHelperVote = (getSigningClient: SigningClientResolver) => buildTx<MsgVote>({
-  getSigningClient: getSigningClient,
+export const buildHelperVote = (clientResolver: SigningClientResolver) => buildTx<MsgVote>({
+  clientResolver,
   typeUrl: MsgVote.typeUrl,
   encoders: toEncoders(MsgVote),
   converters: toConverters(MsgVote)
@@ -23,8 +23,8 @@ export const buildHelperVote = (getSigningClient: SigningClientResolver) => buil
 export const useHelperVote = buildUseMutation<MsgVote, Error>({
   builderMutationFn: buildHelperVote
 });
-export const constructLetsVoteWeighted = (getSigningClient: SigningClientResolver) => buildTx<MsgVoteWeighted>({
-  getSigningClient: getSigningClient,
+export const constructLetsVoteWeighted = (clientResolver: SigningClientResolver) => buildTx<MsgVoteWeighted>({
+  clientResolver,
   typeUrl: MsgVoteWeighted.typeUrl,
   encoders: toEncoders(MsgVoteWeighted),
   converters: toConverters(MsgVoteWeighted)
@@ -32,8 +32,8 @@ export const constructLetsVoteWeighted = (getSigningClient: SigningClientResolve
 export const useTxLetsVoteWeighted = buildUseMutation<MsgVoteWeighted, Error>({
   builderMutationFn: constructLetsVoteWeighted
 });
-export const createToDeposit = (getSigningClient: SigningClientResolver) => buildTx<MsgDeposit>({
-  getSigningClient: getSigningClient,
+export const createToDeposit = (clientResolver: SigningClientResolver) => buildTx<MsgDeposit>({
+  clientResolver,
   typeUrl: MsgDeposit.typeUrl,
   encoders: toEncoders(MsgDeposit),
   converters: toConverters(MsgDeposit)
diff --git a/__fixtures__/v-next/outputhelperfunc/helper-func-types.ts b/__fixtures__/v-next/outputhelperfunc/helper-func-types.ts
index bd44fa62d..ec1132b5a 100644
--- a/__fixtures__/v-next/outputhelperfunc/helper-func-types.ts
+++ b/__fixtures__/v-next/outputhelperfunc/helper-func-types.ts
@@ -5,20 +5,28 @@
 */
 
 
+import { HttpEndpoint } from "@interchainjs/types";
 import { BinaryReader, BinaryWriter } from "./binary";
-import { Rpc } from "./helpers";
+import { getRpcClient } from "./extern";
+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: () => Rpc | undefined
+  clientResolver: RpcResolver
 }
 
 export function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>) {
     return async (request: TReq) => {
-      const rpc = opts.getRpcInstance();
+      let rpc: Rpc | undefined;
+
+      if(isRpc(opts.clientResolver)) {
+        rpc = opts.clientResolver;
+      } else {
+        rpc = await getRpcClient(opts.clientResolver);
+      }
 
       if (!rpc) throw new Error("Query Rpc is not initialized");
 
@@ -35,6 +43,13 @@ export interface ITxArgs<TMsg> {
   memo: string;
 }
 
+export function isISigningClient(client: unknown): client is ISigningClient {
+  return client !== null && client !== undefined
+    && typeof (client as ISigningClient).signAndBroadcast === 'function'
+    && typeof (client as ISigningClient).addConverters === 'function'
+    && typeof (client as ISigningClient).addEncoders === 'function';
+}
+
 export interface ISigningClient {
   /**
    * register converters
@@ -54,7 +69,7 @@ export interface ISigningClient {
 }
 
 export interface TxBuilderOptions {
-  getSigningClient: () => ISigningClient | undefined,
+  clientResolver: SigningClientResolver,
   typeUrl: string,
   encoders?: Encoder[],
   converters?: AminoConverter[],
@@ -67,7 +82,12 @@ export function buildTx<TMsg>(opts: TxBuilderOptions) {
     fee: StdFee | 'auto',
     memo: string
   ): Promise<DeliverTxResponse> => {
-    const client = opts.getSigningClient();
+    let client: ISigningClient | undefined;
+
+    // if opts.getSigningClient is a function, call it to get the SigningClient instance
+    if(isISigningClient(opts.clientResolver)) {
+      client = opts.clientResolver;
+    }
 
     if (!client) throw new Error("SigningClient is not initialized");
 
@@ -167,5 +187,5 @@ export interface AminoConverter {
   toAmino: (data: any) => any;
 }
 
-export type SigningClientResolver = () => ISigningClient | undefined;
-export type RpcResolver = () => Rpc | undefined;
+export type SigningClientResolver = string | HttpEndpoint | ISigningClient;
+export type RpcResolver = string | HttpEndpoint | Rpc ;
diff --git a/__fixtures__/v-next/outputhelperfunc/helpers.ts b/__fixtures__/v-next/outputhelperfunc/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputhelperfunc/helpers.ts
+++ b/__fixtures__/v-next/outputhelperfunc/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputhelperfunc/react-query.ts b/__fixtures__/v-next/outputhelperfunc/react-query.ts
index 65cf59ccc..2b6ca8d72 100644
--- a/__fixtures__/v-next/outputhelperfunc/react-query.ts
+++ b/__fixtures__/v-next/outputhelperfunc/react-query.ts
@@ -4,21 +4,27 @@
 * and run the transpile command or npm scripts command that is used to regenerate this bundle.
 */
 
+
+
+
 import { getRpcClient } from './extern'
 import {
+  isRpc,
   Rpc,
 } from './helpers'
 import {
   ITxArgs,
   ISigningClient,
   StdFee,
-  DeliverTxResponse
+  DeliverTxResponse,
+  SigningClientResolver,
+  RpcResolver,
+  isISigningClient
 } from './helper-func-types'
 import {
     useQuery,
     useQueryClient,
     UseQueryOptions,
-    MutationOptions,
     useMutation,
     UseMutationOptions,
     QueryKey,
@@ -31,13 +37,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 !== null && resolver !== undefined && (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 +73,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');
       }
@@ -109,7 +123,7 @@ export const useTendermintClient = ({
 };
 
 export interface UseQueryBuilderOptions<TReq, TRes> {
-  builderQueryFn: (getRpcInstance: () => Rpc | undefined) => (request: TReq) => Promise<TRes>,
+  builderQueryFn: (clientResolver: RpcResolver) => (request: TReq) => Promise<TRes>,
   queryKeyPrefix: string,
 }
 
@@ -118,37 +132,52 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
   return <TData = TRes>({
     request,
     options,
-    rpcEndpoint,
-    rpcClientQueryKey,
+    clientResolver,
     customizedQueryKey,
   }: UseQueryParams<TReq, TRes, TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [key];
-    const rpc = queryClient.getQueryData<Rpc>(queryKey);
-    const queryFn = opts.builderQueryFn(()=>{
-      return rpc;
-    });
+
+    let rpcResolver: RpcResolver | undefined;
+
+    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 = clientResolver;
+    }
+
+    if(!rpcResolver) {
+      throw new Error('RpcResolver is not initialized');
+    }
+
+    const queryFn = opts.builderQueryFn(rpcResolver);
     return useQuery<TRes, Error, TData>(customizedQueryKey || [opts.queryKeyPrefix, request], () => queryFn(request), options);
   };
 }
 
 export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
   request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
   customizedQueryKey?: QueryKey
 }
 
 export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
   options?: UseMutationOptions<TData, TError, TVariables, TContext>;
-  rpcEndpoint?: string | HttpEndpoint;
-  signingClientQueryKey?: string;
+  clientResolver?: CacheResolver | SigningClientResolver;
 }
 
 
 export interface UseMutationBuilderOptions<TMsg> {
-  builderMutationFn: (getSigningClientInstance: () => ISigningClient | undefined) => (
+  builderMutationFn: (getSigningClientInstance: SigningClientResolver) => (
     signerAddress: string,
     message: TMsg,
     fee: StdFee | 'auto',
@@ -160,19 +189,29 @@ export interface UseMutationBuilderOptions<TMsg> {
 export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
   return ({
     options,
-    rpcEndpoint,
-    signingClientQueryKey
+    clientResolver
   }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = signingClientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [DEFAULT_SIGNING_CLIENT_QUERY_KEY];
-    const signingClient = queryClient.getQueryData<ISigningClient>(queryKey);
 
-    const mutationFn = opts.builderMutationFn(() => {
-      return signingClient;
-    });
+    let signingClientResolver: SigningClientResolver | undefined;
+
+    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 {
+      clientResolver = clientResolver;
+    }
+
+    if(!signingClientResolver) {
+      throw new Error('SigningClientResolver is not initialized');
+    }
+
+    const mutationFn = opts.builderMutationFn(signingClientResolver);
 
     return useMutation<DeliverTxResponse, Error, ITxArgs<TMsg>>(
       (reqData: ITxArgs<TMsg>) => mutationFn(reqData.signerAddress, reqData.message, reqData.fee, reqData.memo),
diff --git a/__fixtures__/v-next/outputicjs/akash/audit/v1beta1/audit.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/audit/v1beta1/audit.rpc.func.ts
index 250106d07..14c3a83ac 100644
--- a/__fixtures__/v-next/outputicjs/akash/audit/v1beta1/audit.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/audit/v1beta1/audit.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 { MsgSignProviderAttributes, MsgDeleteProviderAttributes } from "./audit";
-export const createSignProviderAttributes = (getSigningClient: SigningClientResolver) => buildTx<MsgSignProviderAttributes>({
-  getSigningClient: getSigningClient,
+export const createSignProviderAttributes = (clientResolver: SigningClientResolver) => buildTx<MsgSignProviderAttributes>({
+  clientResolver,
   typeUrl: MsgSignProviderAttributes.typeUrl,
   encoders: toEncoders(MsgSignProviderAttributes),
   converters: toConverters(MsgSignProviderAttributes)
@@ -11,8 +11,8 @@ export const createSignProviderAttributes = (getSigningClient: SigningClientReso
 export const useSignProviderAttributes = buildUseMutation<MsgSignProviderAttributes, Error>({
   builderMutationFn: createSignProviderAttributes
 });
-export const createDeleteProviderAttributes = (getSigningClient: SigningClientResolver) => buildTx<MsgDeleteProviderAttributes>({
-  getSigningClient: getSigningClient,
+export const createDeleteProviderAttributes = (clientResolver: SigningClientResolver) => buildTx<MsgDeleteProviderAttributes>({
+  clientResolver,
   typeUrl: MsgDeleteProviderAttributes.typeUrl,
   encoders: toEncoders(MsgDeleteProviderAttributes),
   converters: toConverters(MsgDeleteProviderAttributes)
diff --git a/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/audit.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/audit.rpc.func.ts
index 250106d07..14c3a83ac 100644
--- a/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/audit.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/audit.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 { MsgSignProviderAttributes, MsgDeleteProviderAttributes } from "./audit";
-export const createSignProviderAttributes = (getSigningClient: SigningClientResolver) => buildTx<MsgSignProviderAttributes>({
-  getSigningClient: getSigningClient,
+export const createSignProviderAttributes = (clientResolver: SigningClientResolver) => buildTx<MsgSignProviderAttributes>({
+  clientResolver,
   typeUrl: MsgSignProviderAttributes.typeUrl,
   encoders: toEncoders(MsgSignProviderAttributes),
   converters: toConverters(MsgSignProviderAttributes)
@@ -11,8 +11,8 @@ export const createSignProviderAttributes = (getSigningClient: SigningClientReso
 export const useSignProviderAttributes = buildUseMutation<MsgSignProviderAttributes, Error>({
   builderMutationFn: createSignProviderAttributes
 });
-export const createDeleteProviderAttributes = (getSigningClient: SigningClientResolver) => buildTx<MsgDeleteProviderAttributes>({
-  getSigningClient: getSigningClient,
+export const createDeleteProviderAttributes = (clientResolver: SigningClientResolver) => buildTx<MsgDeleteProviderAttributes>({
+  clientResolver,
   typeUrl: MsgDeleteProviderAttributes.typeUrl,
   encoders: toEncoders(MsgDeleteProviderAttributes),
   converters: toConverters(MsgDeleteProviderAttributes)
diff --git a/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/query.rpc.func.ts
index 338094efb..2f73fe696 100644
--- a/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/audit/v1beta2/query.rpc.func.ts
@@ -1,45 +1,45 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAllProvidersAttributesRequest, QueryProvidersResponse, QueryProviderAttributesRequest, QueryProviderAuditorRequest, QueryAuditorAttributesRequest } from "./query";
-export const createGetAllProvidersAttributes = (getRpcInstance: RpcResolver) => buildQuery<QueryAllProvidersAttributesRequest, QueryProvidersResponse>({
+export const createGetAllProvidersAttributes = (clientResolver: RpcResolver) => buildQuery<QueryAllProvidersAttributesRequest, QueryProvidersResponse>({
   encode: QueryAllProvidersAttributesRequest.encode,
   decode: QueryProvidersResponse.decode,
   service: "akash.audit.v1beta2.Query",
   method: "AllProvidersAttributes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllProvidersAttributes = buildUseQuery<QueryAllProvidersAttributesRequest, QueryProvidersResponse>({
   builderQueryFn: createGetAllProvidersAttributes,
   queryKeyPrefix: "AllProvidersAttributesQuery"
 });
-export const createGetProviderAttributes = (getRpcInstance: RpcResolver) => buildQuery<QueryProviderAttributesRequest, QueryProvidersResponse>({
+export const createGetProviderAttributes = (clientResolver: RpcResolver) => buildQuery<QueryProviderAttributesRequest, QueryProvidersResponse>({
   encode: QueryProviderAttributesRequest.encode,
   decode: QueryProvidersResponse.decode,
   service: "akash.audit.v1beta2.Query",
   method: "ProviderAttributes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProviderAttributes = buildUseQuery<QueryProviderAttributesRequest, QueryProvidersResponse>({
   builderQueryFn: createGetProviderAttributes,
   queryKeyPrefix: "ProviderAttributesQuery"
 });
-export const createGetProviderAuditorAttributes = (getRpcInstance: RpcResolver) => buildQuery<QueryProviderAuditorRequest, QueryProvidersResponse>({
+export const createGetProviderAuditorAttributes = (clientResolver: RpcResolver) => buildQuery<QueryProviderAuditorRequest, QueryProvidersResponse>({
   encode: QueryProviderAuditorRequest.encode,
   decode: QueryProvidersResponse.decode,
   service: "akash.audit.v1beta2.Query",
   method: "ProviderAuditorAttributes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProviderAuditorAttributes = buildUseQuery<QueryProviderAuditorRequest, QueryProvidersResponse>({
   builderQueryFn: createGetProviderAuditorAttributes,
   queryKeyPrefix: "ProviderAuditorAttributesQuery"
 });
-export const createGetAuditorAttributes = (getRpcInstance: RpcResolver) => buildQuery<QueryAuditorAttributesRequest, QueryProvidersResponse>({
+export const createGetAuditorAttributes = (clientResolver: RpcResolver) => buildQuery<QueryAuditorAttributesRequest, QueryProvidersResponse>({
   encode: QueryAuditorAttributesRequest.encode,
   decode: QueryProvidersResponse.decode,
   service: "akash.audit.v1beta2.Query",
   method: "AuditorAttributes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAuditorAttributes = buildUseQuery<QueryAuditorAttributesRequest, QueryProvidersResponse>({
   builderQueryFn: createGetAuditorAttributes,
diff --git a/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/cert.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/cert.rpc.func.ts
index c89045581..881c126aa 100644
--- a/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/cert.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/cert.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 { MsgCreateCertificate, MsgRevokeCertificate } from "./cert";
-export const createCreateCertificate = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateCertificate>({
-  getSigningClient: getSigningClient,
+export const createCreateCertificate = (clientResolver: SigningClientResolver) => buildTx<MsgCreateCertificate>({
+  clientResolver,
   typeUrl: MsgCreateCertificate.typeUrl,
   encoders: toEncoders(MsgCreateCertificate),
   converters: toConverters(MsgCreateCertificate)
@@ -11,8 +11,8 @@ export const createCreateCertificate = (getSigningClient: SigningClientResolver)
 export const useCreateCertificate = buildUseMutation<MsgCreateCertificate, Error>({
   builderMutationFn: createCreateCertificate
 });
-export const createRevokeCertificate = (getSigningClient: SigningClientResolver) => buildTx<MsgRevokeCertificate>({
-  getSigningClient: getSigningClient,
+export const createRevokeCertificate = (clientResolver: SigningClientResolver) => buildTx<MsgRevokeCertificate>({
+  clientResolver,
   typeUrl: MsgRevokeCertificate.typeUrl,
   encoders: toEncoders(MsgRevokeCertificate),
   converters: toConverters(MsgRevokeCertificate)
diff --git a/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/query.rpc.func.ts
index b86c96165..2e914769a 100644
--- a/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/cert/v1beta2/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryCertificatesRequest, QueryCertificatesResponse } from "./query";
-export const createGetCertificates = (getRpcInstance: RpcResolver) => buildQuery<QueryCertificatesRequest, QueryCertificatesResponse>({
+export const createGetCertificates = (clientResolver: RpcResolver) => buildQuery<QueryCertificatesRequest, QueryCertificatesResponse>({
   encode: QueryCertificatesRequest.encode,
   decode: QueryCertificatesResponse.decode,
   service: "akash.cert.v1beta2.Query",
   method: "Certificates",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCertificates = buildUseQuery<QueryCertificatesRequest, QueryCertificatesResponse>({
   builderQueryFn: createGetCertificates,
diff --git a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/deployment.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/deployment.rpc.func.ts
index ca44f1774..b21d9bd6b 100644
--- a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/deployment.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/deployment.rpc.func.ts
@@ -3,8 +3,8 @@ import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateDeployment, MsgDepositDeployment, MsgUpdateDeployment, MsgCloseDeployment } from "./deployment";
-export const createCreateDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateDeployment>({
-  getSigningClient: getSigningClient,
+export const createCreateDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgCreateDeployment>({
+  clientResolver,
   typeUrl: MsgCreateDeployment.typeUrl,
   encoders: toEncoders(MsgCreateDeployment),
   converters: toConverters(MsgCreateDeployment)
@@ -12,8 +12,8 @@ export const createCreateDeployment = (getSigningClient: SigningClientResolver)
 export const useCreateDeployment = buildUseMutation<MsgCreateDeployment, Error>({
   builderMutationFn: createCreateDeployment
 });
-export const createDepositDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgDepositDeployment>({
-  getSigningClient: getSigningClient,
+export const createDepositDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgDepositDeployment>({
+  clientResolver,
   typeUrl: MsgDepositDeployment.typeUrl,
   encoders: toEncoders(MsgDepositDeployment),
   converters: toConverters(MsgDepositDeployment)
@@ -21,8 +21,8 @@ export const createDepositDeployment = (getSigningClient: SigningClientResolver)
 export const useDepositDeployment = buildUseMutation<MsgDepositDeployment, Error>({
   builderMutationFn: createDepositDeployment
 });
-export const createUpdateDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateDeployment>({
-  getSigningClient: getSigningClient,
+export const createUpdateDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateDeployment>({
+  clientResolver,
   typeUrl: MsgUpdateDeployment.typeUrl,
   encoders: toEncoders(MsgUpdateDeployment),
   converters: toConverters(MsgUpdateDeployment)
@@ -30,8 +30,8 @@ export const createUpdateDeployment = (getSigningClient: SigningClientResolver)
 export const useUpdateDeployment = buildUseMutation<MsgUpdateDeployment, Error>({
   builderMutationFn: createUpdateDeployment
 });
-export const createCloseDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseDeployment>({
-  getSigningClient: getSigningClient,
+export const createCloseDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgCloseDeployment>({
+  clientResolver,
   typeUrl: MsgCloseDeployment.typeUrl,
   encoders: toEncoders(MsgCloseDeployment),
   converters: toConverters(MsgCloseDeployment)
@@ -39,8 +39,8 @@ export const createCloseDeployment = (getSigningClient: SigningClientResolver) =
 export const useCloseDeployment = buildUseMutation<MsgCloseDeployment, Error>({
   builderMutationFn: createCloseDeployment
 });
-export const createCloseGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseGroup>({
-  getSigningClient: getSigningClient,
+export const createCloseGroup = (clientResolver: SigningClientResolver) => buildTx<MsgCloseGroup>({
+  clientResolver,
   typeUrl: MsgCloseGroup.typeUrl,
   encoders: toEncoders(MsgCloseGroup),
   converters: toConverters(MsgCloseGroup)
@@ -48,8 +48,8 @@ export const createCloseGroup = (getSigningClient: SigningClientResolver) => bui
 export const useCloseGroup = buildUseMutation<MsgCloseGroup, Error>({
   builderMutationFn: createCloseGroup
 });
-export const createPauseGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgPauseGroup>({
-  getSigningClient: getSigningClient,
+export const createPauseGroup = (clientResolver: SigningClientResolver) => buildTx<MsgPauseGroup>({
+  clientResolver,
   typeUrl: MsgPauseGroup.typeUrl,
   encoders: toEncoders(MsgPauseGroup),
   converters: toConverters(MsgPauseGroup)
@@ -57,8 +57,8 @@ export const createPauseGroup = (getSigningClient: SigningClientResolver) => bui
 export const usePauseGroup = buildUseMutation<MsgPauseGroup, Error>({
   builderMutationFn: createPauseGroup
 });
-export const createStartGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgStartGroup>({
-  getSigningClient: getSigningClient,
+export const createStartGroup = (clientResolver: SigningClientResolver) => buildTx<MsgStartGroup>({
+  clientResolver,
   typeUrl: MsgStartGroup.typeUrl,
   encoders: toEncoders(MsgStartGroup),
   converters: toConverters(MsgStartGroup)
diff --git a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/query.rpc.func.ts
index 12106daa3..f9965806f 100644
--- a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryDeploymentsRequest, QueryDeploymentsResponse, QueryDeploymentRequest, QueryDeploymentResponse, QueryGroupRequest, QueryGroupResponse } from "./query";
-export const createGetDeployments = (getRpcInstance: RpcResolver) => buildQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
+export const createGetDeployments = (clientResolver: RpcResolver) => buildQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
   encode: QueryDeploymentsRequest.encode,
   decode: QueryDeploymentsResponse.decode,
   service: "akash.deployment.v1beta1.Query",
   method: "Deployments",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeployments = buildUseQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
   builderQueryFn: createGetDeployments,
   queryKeyPrefix: "DeploymentsQuery"
 });
-export const createGetDeployment = (getRpcInstance: RpcResolver) => buildQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
+export const createGetDeployment = (clientResolver: RpcResolver) => buildQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
   encode: QueryDeploymentRequest.encode,
   decode: QueryDeploymentResponse.decode,
   service: "akash.deployment.v1beta1.Query",
   method: "Deployment",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeployment = buildUseQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
   builderQueryFn: createGetDeployment,
   queryKeyPrefix: "DeploymentQuery"
 });
-export const createGetGroup = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupRequest, QueryGroupResponse>({
+export const createGetGroup = (clientResolver: RpcResolver) => buildQuery<QueryGroupRequest, QueryGroupResponse>({
   encode: QueryGroupRequest.encode,
   decode: QueryGroupResponse.decode,
   service: "akash.deployment.v1beta1.Query",
   method: "Group",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroup = buildUseQuery<QueryGroupRequest, QueryGroupResponse>({
   builderQueryFn: createGetGroup,
diff --git a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/query.rpc.func.ts
index 01524ac05..1dd1b5a42 100644
--- a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryDeploymentsRequest, QueryDeploymentsResponse, QueryDeploymentRequest, QueryDeploymentResponse, QueryGroupRequest, QueryGroupResponse } from "./query";
-export const createGetDeployments = (getRpcInstance: RpcResolver) => buildQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
+export const createGetDeployments = (clientResolver: RpcResolver) => buildQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
   encode: QueryDeploymentsRequest.encode,
   decode: QueryDeploymentsResponse.decode,
   service: "akash.deployment.v1beta2.Query",
   method: "Deployments",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeployments = buildUseQuery<QueryDeploymentsRequest, QueryDeploymentsResponse>({
   builderQueryFn: createGetDeployments,
   queryKeyPrefix: "DeploymentsQuery"
 });
-export const createGetDeployment = (getRpcInstance: RpcResolver) => buildQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
+export const createGetDeployment = (clientResolver: RpcResolver) => buildQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
   encode: QueryDeploymentRequest.encode,
   decode: QueryDeploymentResponse.decode,
   service: "akash.deployment.v1beta2.Query",
   method: "Deployment",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeployment = buildUseQuery<QueryDeploymentRequest, QueryDeploymentResponse>({
   builderQueryFn: createGetDeployment,
   queryKeyPrefix: "DeploymentQuery"
 });
-export const createGetGroup = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupRequest, QueryGroupResponse>({
+export const createGetGroup = (clientResolver: RpcResolver) => buildQuery<QueryGroupRequest, QueryGroupResponse>({
   encode: QueryGroupRequest.encode,
   decode: QueryGroupResponse.decode,
   service: "akash.deployment.v1beta2.Query",
   method: "Group",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroup = buildUseQuery<QueryGroupRequest, QueryGroupResponse>({
   builderQueryFn: createGetGroup,
diff --git a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/service.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/service.rpc.func.ts
index 965bdbe80..38d586f73 100644
--- a/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/service.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/deployment/v1beta2/service.rpc.func.ts
@@ -3,8 +3,8 @@ import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
 import { MsgCreateDeployment, MsgDepositDeployment, MsgUpdateDeployment, MsgCloseDeployment } from "./deploymentmsg";
 import { MsgCloseGroup, MsgPauseGroup, MsgStartGroup } from "./groupmsg";
-export const createCreateDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateDeployment>({
-  getSigningClient: getSigningClient,
+export const createCreateDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgCreateDeployment>({
+  clientResolver,
   typeUrl: MsgCreateDeployment.typeUrl,
   encoders: toEncoders(MsgCreateDeployment),
   converters: toConverters(MsgCreateDeployment)
@@ -12,8 +12,8 @@ export const createCreateDeployment = (getSigningClient: SigningClientResolver)
 export const useCreateDeployment = buildUseMutation<MsgCreateDeployment, Error>({
   builderMutationFn: createCreateDeployment
 });
-export const createDepositDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgDepositDeployment>({
-  getSigningClient: getSigningClient,
+export const createDepositDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgDepositDeployment>({
+  clientResolver,
   typeUrl: MsgDepositDeployment.typeUrl,
   encoders: toEncoders(MsgDepositDeployment),
   converters: toConverters(MsgDepositDeployment)
@@ -21,8 +21,8 @@ export const createDepositDeployment = (getSigningClient: SigningClientResolver)
 export const useDepositDeployment = buildUseMutation<MsgDepositDeployment, Error>({
   builderMutationFn: createDepositDeployment
 });
-export const createUpdateDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateDeployment>({
-  getSigningClient: getSigningClient,
+export const createUpdateDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateDeployment>({
+  clientResolver,
   typeUrl: MsgUpdateDeployment.typeUrl,
   encoders: toEncoders(MsgUpdateDeployment),
   converters: toConverters(MsgUpdateDeployment)
@@ -30,8 +30,8 @@ export const createUpdateDeployment = (getSigningClient: SigningClientResolver)
 export const useUpdateDeployment = buildUseMutation<MsgUpdateDeployment, Error>({
   builderMutationFn: createUpdateDeployment
 });
-export const createCloseDeployment = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseDeployment>({
-  getSigningClient: getSigningClient,
+export const createCloseDeployment = (clientResolver: SigningClientResolver) => buildTx<MsgCloseDeployment>({
+  clientResolver,
   typeUrl: MsgCloseDeployment.typeUrl,
   encoders: toEncoders(MsgCloseDeployment),
   converters: toConverters(MsgCloseDeployment)
@@ -39,8 +39,8 @@ export const createCloseDeployment = (getSigningClient: SigningClientResolver) =
 export const useCloseDeployment = buildUseMutation<MsgCloseDeployment, Error>({
   builderMutationFn: createCloseDeployment
 });
-export const createCloseGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseGroup>({
-  getSigningClient: getSigningClient,
+export const createCloseGroup = (clientResolver: SigningClientResolver) => buildTx<MsgCloseGroup>({
+  clientResolver,
   typeUrl: MsgCloseGroup.typeUrl,
   encoders: toEncoders(MsgCloseGroup),
   converters: toConverters(MsgCloseGroup)
@@ -48,8 +48,8 @@ export const createCloseGroup = (getSigningClient: SigningClientResolver) => bui
 export const useCloseGroup = buildUseMutation<MsgCloseGroup, Error>({
   builderMutationFn: createCloseGroup
 });
-export const createPauseGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgPauseGroup>({
-  getSigningClient: getSigningClient,
+export const createPauseGroup = (clientResolver: SigningClientResolver) => buildTx<MsgPauseGroup>({
+  clientResolver,
   typeUrl: MsgPauseGroup.typeUrl,
   encoders: toEncoders(MsgPauseGroup),
   converters: toConverters(MsgPauseGroup)
@@ -57,8 +57,8 @@ export const createPauseGroup = (getSigningClient: SigningClientResolver) => bui
 export const usePauseGroup = buildUseMutation<MsgPauseGroup, Error>({
   builderMutationFn: createPauseGroup
 });
-export const createStartGroup = (getSigningClient: SigningClientResolver) => buildTx<MsgStartGroup>({
-  getSigningClient: getSigningClient,
+export const createStartGroup = (clientResolver: SigningClientResolver) => buildTx<MsgStartGroup>({
+  clientResolver,
   typeUrl: MsgStartGroup.typeUrl,
   encoders: toEncoders(MsgStartGroup),
   converters: toConverters(MsgStartGroup)
diff --git a/__fixtures__/v-next/outputicjs/akash/escrow/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/escrow/v1beta1/query.rpc.func.ts
index 0aa868170..0b083cbc9 100644
--- a/__fixtures__/v-next/outputicjs/akash/escrow/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/escrow/v1beta1/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAccountsRequest, QueryAccountsResponse, QueryPaymentsRequest, QueryPaymentsResponse } 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: "akash.escrow.v1beta1.Query",
   method: "Accounts",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccounts = buildUseQuery<QueryAccountsRequest, QueryAccountsResponse>({
   builderQueryFn: createGetAccounts,
   queryKeyPrefix: "AccountsQuery"
 });
-export const createGetPayments = (getRpcInstance: RpcResolver) => buildQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
+export const createGetPayments = (clientResolver: RpcResolver) => buildQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
   encode: QueryPaymentsRequest.encode,
   decode: QueryPaymentsResponse.decode,
   service: "akash.escrow.v1beta1.Query",
   method: "Payments",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPayments = buildUseQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
   builderQueryFn: createGetPayments,
diff --git a/__fixtures__/v-next/outputicjs/akash/escrow/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/escrow/v1beta2/query.rpc.func.ts
index aafd37a85..bc34f8553 100644
--- a/__fixtures__/v-next/outputicjs/akash/escrow/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/escrow/v1beta2/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAccountsRequest, QueryAccountsResponse, QueryPaymentsRequest, QueryPaymentsResponse } 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: "akash.escrow.v1beta2.Query",
   method: "Accounts",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccounts = buildUseQuery<QueryAccountsRequest, QueryAccountsResponse>({
   builderQueryFn: createGetAccounts,
   queryKeyPrefix: "AccountsQuery"
 });
-export const createGetPayments = (getRpcInstance: RpcResolver) => buildQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
+export const createGetPayments = (clientResolver: RpcResolver) => buildQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
   encode: QueryPaymentsRequest.encode,
   decode: QueryPaymentsResponse.decode,
   service: "akash.escrow.v1beta2.Query",
   method: "Payments",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPayments = buildUseQuery<QueryPaymentsRequest, QueryPaymentsResponse>({
   builderQueryFn: createGetPayments,
diff --git a/__fixtures__/v-next/outputicjs/akash/market/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/market/v1beta2/query.rpc.func.ts
index 752663d71..fc4c3ea75 100644
--- a/__fixtures__/v-next/outputicjs/akash/market/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/market/v1beta2/query.rpc.func.ts
@@ -1,67 +1,67 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryOrdersRequest, QueryOrdersResponse, QueryOrderRequest, QueryOrderResponse, QueryBidsRequest, QueryBidsResponse, QueryBidRequest, QueryBidResponse, QueryLeasesRequest, QueryLeasesResponse, QueryLeaseRequest, QueryLeaseResponse } from "./query";
-export const createGetOrders = (getRpcInstance: RpcResolver) => buildQuery<QueryOrdersRequest, QueryOrdersResponse>({
+export const createGetOrders = (clientResolver: RpcResolver) => buildQuery<QueryOrdersRequest, QueryOrdersResponse>({
   encode: QueryOrdersRequest.encode,
   decode: QueryOrdersResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Orders",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetOrders = buildUseQuery<QueryOrdersRequest, QueryOrdersResponse>({
   builderQueryFn: createGetOrders,
   queryKeyPrefix: "OrdersQuery"
 });
-export const createGetOrder = (getRpcInstance: RpcResolver) => buildQuery<QueryOrderRequest, QueryOrderResponse>({
+export const createGetOrder = (clientResolver: RpcResolver) => buildQuery<QueryOrderRequest, QueryOrderResponse>({
   encode: QueryOrderRequest.encode,
   decode: QueryOrderResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Order",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetOrder = buildUseQuery<QueryOrderRequest, QueryOrderResponse>({
   builderQueryFn: createGetOrder,
   queryKeyPrefix: "OrderQuery"
 });
-export const createGetBids = (getRpcInstance: RpcResolver) => buildQuery<QueryBidsRequest, QueryBidsResponse>({
+export const createGetBids = (clientResolver: RpcResolver) => buildQuery<QueryBidsRequest, QueryBidsResponse>({
   encode: QueryBidsRequest.encode,
   decode: QueryBidsResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Bids",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBids = buildUseQuery<QueryBidsRequest, QueryBidsResponse>({
   builderQueryFn: createGetBids,
   queryKeyPrefix: "BidsQuery"
 });
-export const createGetBid = (getRpcInstance: RpcResolver) => buildQuery<QueryBidRequest, QueryBidResponse>({
+export const createGetBid = (clientResolver: RpcResolver) => buildQuery<QueryBidRequest, QueryBidResponse>({
   encode: QueryBidRequest.encode,
   decode: QueryBidResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Bid",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBid = buildUseQuery<QueryBidRequest, QueryBidResponse>({
   builderQueryFn: createGetBid,
   queryKeyPrefix: "BidQuery"
 });
-export const createGetLeases = (getRpcInstance: RpcResolver) => buildQuery<QueryLeasesRequest, QueryLeasesResponse>({
+export const createGetLeases = (clientResolver: RpcResolver) => buildQuery<QueryLeasesRequest, QueryLeasesResponse>({
   encode: QueryLeasesRequest.encode,
   decode: QueryLeasesResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Leases",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLeases = buildUseQuery<QueryLeasesRequest, QueryLeasesResponse>({
   builderQueryFn: createGetLeases,
   queryKeyPrefix: "LeasesQuery"
 });
-export const createGetLease = (getRpcInstance: RpcResolver) => buildQuery<QueryLeaseRequest, QueryLeaseResponse>({
+export const createGetLease = (clientResolver: RpcResolver) => buildQuery<QueryLeaseRequest, QueryLeaseResponse>({
   encode: QueryLeaseRequest.encode,
   decode: QueryLeaseResponse.decode,
   service: "akash.market.v1beta2.Query",
   method: "Lease",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLease = buildUseQuery<QueryLeaseRequest, QueryLeaseResponse>({
   builderQueryFn: createGetLease,
diff --git a/__fixtures__/v-next/outputicjs/akash/market/v1beta2/service.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/market/v1beta2/service.rpc.func.ts
index 6353b66e4..42ac5e747 100644
--- a/__fixtures__/v-next/outputicjs/akash/market/v1beta2/service.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/market/v1beta2/service.rpc.func.ts
@@ -3,8 +3,8 @@ import { MsgWithdrawLease, MsgCreateLease, MsgCloseLease } from "./lease";
 import { buildTx, SigningClientResolver } from "../../../helper-func-types";
 import { buildUseMutation } from "../../../react-query";
 import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
-export const createCreateBid = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateBid>({
-  getSigningClient: getSigningClient,
+export const createCreateBid = (clientResolver: SigningClientResolver) => buildTx<MsgCreateBid>({
+  clientResolver,
   typeUrl: MsgCreateBid.typeUrl,
   encoders: toEncoders(MsgCreateBid),
   converters: toConverters(MsgCreateBid)
@@ -12,8 +12,8 @@ export const createCreateBid = (getSigningClient: SigningClientResolver) => buil
 export const useCreateBid = buildUseMutation<MsgCreateBid, Error>({
   builderMutationFn: createCreateBid
 });
-export const createCloseBid = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseBid>({
-  getSigningClient: getSigningClient,
+export const createCloseBid = (clientResolver: SigningClientResolver) => buildTx<MsgCloseBid>({
+  clientResolver,
   typeUrl: MsgCloseBid.typeUrl,
   encoders: toEncoders(MsgCloseBid),
   converters: toConverters(MsgCloseBid)
@@ -21,8 +21,8 @@ export const createCloseBid = (getSigningClient: SigningClientResolver) => build
 export const useCloseBid = buildUseMutation<MsgCloseBid, Error>({
   builderMutationFn: createCloseBid
 });
-export const createWithdrawLease = (getSigningClient: SigningClientResolver) => buildTx<MsgWithdrawLease>({
-  getSigningClient: getSigningClient,
+export const createWithdrawLease = (clientResolver: SigningClientResolver) => buildTx<MsgWithdrawLease>({
+  clientResolver,
   typeUrl: MsgWithdrawLease.typeUrl,
   encoders: toEncoders(MsgWithdrawLease),
   converters: toConverters(MsgWithdrawLease)
@@ -30,8 +30,8 @@ export const createWithdrawLease = (getSigningClient: SigningClientResolver) =>
 export const useWithdrawLease = buildUseMutation<MsgWithdrawLease, Error>({
   builderMutationFn: createWithdrawLease
 });
-export const createCreateLease = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateLease>({
-  getSigningClient: getSigningClient,
+export const createCreateLease = (clientResolver: SigningClientResolver) => buildTx<MsgCreateLease>({
+  clientResolver,
   typeUrl: MsgCreateLease.typeUrl,
   encoders: toEncoders(MsgCreateLease),
   converters: toConverters(MsgCreateLease)
@@ -39,8 +39,8 @@ export const createCreateLease = (getSigningClient: SigningClientResolver) => bu
 export const useCreateLease = buildUseMutation<MsgCreateLease, Error>({
   builderMutationFn: createCreateLease
 });
-export const createCloseLease = (getSigningClient: SigningClientResolver) => buildTx<MsgCloseLease>({
-  getSigningClient: getSigningClient,
+export const createCloseLease = (clientResolver: SigningClientResolver) => buildTx<MsgCloseLease>({
+  clientResolver,
   typeUrl: MsgCloseLease.typeUrl,
   encoders: toEncoders(MsgCloseLease),
   converters: toConverters(MsgCloseLease)
diff --git a/__fixtures__/v-next/outputicjs/akash/provider/v1beta1/provider.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/provider/v1beta1/provider.rpc.func.ts
index 62c9ef6bb..c7c5d68ec 100644
--- a/__fixtures__/v-next/outputicjs/akash/provider/v1beta1/provider.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/provider/v1beta1/provider.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 { MsgCreateProvider, MsgUpdateProvider, MsgDeleteProvider } from "./provider";
-export const createCreateProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateProvider>({
-  getSigningClient: getSigningClient,
+export const createCreateProvider = (clientResolver: SigningClientResolver) => buildTx<MsgCreateProvider>({
+  clientResolver,
   typeUrl: MsgCreateProvider.typeUrl,
   encoders: toEncoders(MsgCreateProvider),
   converters: toConverters(MsgCreateProvider)
@@ -11,8 +11,8 @@ export const createCreateProvider = (getSigningClient: SigningClientResolver) =>
 export const useCreateProvider = buildUseMutation<MsgCreateProvider, Error>({
   builderMutationFn: createCreateProvider
 });
-export const createUpdateProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateProvider>({
-  getSigningClient: getSigningClient,
+export const createUpdateProvider = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateProvider>({
+  clientResolver,
   typeUrl: MsgUpdateProvider.typeUrl,
   encoders: toEncoders(MsgUpdateProvider),
   converters: toConverters(MsgUpdateProvider)
@@ -20,8 +20,8 @@ export const createUpdateProvider = (getSigningClient: SigningClientResolver) =>
 export const useUpdateProvider = buildUseMutation<MsgUpdateProvider, Error>({
   builderMutationFn: createUpdateProvider
 });
-export const createDeleteProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgDeleteProvider>({
-  getSigningClient: getSigningClient,
+export const createDeleteProvider = (clientResolver: SigningClientResolver) => buildTx<MsgDeleteProvider>({
+  clientResolver,
   typeUrl: MsgDeleteProvider.typeUrl,
   encoders: toEncoders(MsgDeleteProvider),
   converters: toConverters(MsgDeleteProvider)
diff --git a/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/provider.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/provider.rpc.func.ts
index 62c9ef6bb..c7c5d68ec 100644
--- a/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/provider.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/provider.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 { MsgCreateProvider, MsgUpdateProvider, MsgDeleteProvider } from "./provider";
-export const createCreateProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateProvider>({
-  getSigningClient: getSigningClient,
+export const createCreateProvider = (clientResolver: SigningClientResolver) => buildTx<MsgCreateProvider>({
+  clientResolver,
   typeUrl: MsgCreateProvider.typeUrl,
   encoders: toEncoders(MsgCreateProvider),
   converters: toConverters(MsgCreateProvider)
@@ -11,8 +11,8 @@ export const createCreateProvider = (getSigningClient: SigningClientResolver) =>
 export const useCreateProvider = buildUseMutation<MsgCreateProvider, Error>({
   builderMutationFn: createCreateProvider
 });
-export const createUpdateProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateProvider>({
-  getSigningClient: getSigningClient,
+export const createUpdateProvider = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateProvider>({
+  clientResolver,
   typeUrl: MsgUpdateProvider.typeUrl,
   encoders: toEncoders(MsgUpdateProvider),
   converters: toConverters(MsgUpdateProvider)
@@ -20,8 +20,8 @@ export const createUpdateProvider = (getSigningClient: SigningClientResolver) =>
 export const useUpdateProvider = buildUseMutation<MsgUpdateProvider, Error>({
   builderMutationFn: createUpdateProvider
 });
-export const createDeleteProvider = (getSigningClient: SigningClientResolver) => buildTx<MsgDeleteProvider>({
-  getSigningClient: getSigningClient,
+export const createDeleteProvider = (clientResolver: SigningClientResolver) => buildTx<MsgDeleteProvider>({
+  clientResolver,
   typeUrl: MsgDeleteProvider.typeUrl,
   encoders: toEncoders(MsgDeleteProvider),
   converters: toConverters(MsgDeleteProvider)
diff --git a/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/query.rpc.func.ts
index 90199b2f1..e70baf6f1 100644
--- a/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/akash/provider/v1beta2/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryProvidersRequest, QueryProvidersResponse, QueryProviderRequest, QueryProviderResponse } from "./query";
-export const createGetProviders = (getRpcInstance: RpcResolver) => buildQuery<QueryProvidersRequest, QueryProvidersResponse>({
+export const createGetProviders = (clientResolver: RpcResolver) => buildQuery<QueryProvidersRequest, QueryProvidersResponse>({
   encode: QueryProvidersRequest.encode,
   decode: QueryProvidersResponse.decode,
   service: "akash.provider.v1beta2.Query",
   method: "Providers",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProviders = buildUseQuery<QueryProvidersRequest, QueryProvidersResponse>({
   builderQueryFn: createGetProviders,
   queryKeyPrefix: "ProvidersQuery"
 });
-export const createGetProvider = (getRpcInstance: RpcResolver) => buildQuery<QueryProviderRequest, QueryProviderResponse>({
+export const createGetProvider = (clientResolver: RpcResolver) => buildQuery<QueryProviderRequest, QueryProviderResponse>({
   encode: QueryProviderRequest.encode,
   decode: QueryProviderResponse.decode,
   service: "akash.provider.v1beta2.Query",
   method: "Provider",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProvider = buildUseQuery<QueryProviderRequest, QueryProviderResponse>({
   builderQueryFn: createGetProvider,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/app/v1alpha1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/app/v1alpha1/query.rpc.func.ts
index ac6a688fc..9e27b6af9 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/app/v1alpha1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/app/v1alpha1/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryConfigRequest, QueryConfigResponse } from "./query";
-export const createGetConfig = (getRpcInstance: RpcResolver) => buildQuery<QueryConfigRequest, QueryConfigResponse>({
+export const createGetConfig = (clientResolver: RpcResolver) => buildQuery<QueryConfigRequest, QueryConfigResponse>({
   encode: QueryConfigRequest.encode,
   decode: QueryConfigResponse.decode,
   service: "cosmos.app.v1alpha1.Query",
   method: "Config",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConfig = buildUseQuery<QueryConfigRequest, QueryConfigResponse>({
   builderQueryFn: createGetConfig,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/auth/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/auth/v1beta1/query.rpc.func.ts
index 9e23360f6..cf59e7559 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/auth/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/auth/v1beta1/query.rpc.func.ts
@@ -1,78 +1,78 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAccountsRequest, QueryAccountsResponse, QueryAccountRequest, QueryAccountResponse, QueryParamsRequest, QueryParamsResponse, QueryModuleAccountsRequest, QueryModuleAccountsResponse, Bech32PrefixRequest, Bech32PrefixResponse, AddressBytesToStringRequest, AddressBytesToStringResponse, AddressStringToBytesRequest, AddressStringToBytesResponse } 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 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 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,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/query.rpc.func.ts
index 5f40c3d6b..404f08acd 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryGrantsRequest, QueryGrantsResponse, QueryGranterGrantsRequest, QueryGranterGrantsResponse, QueryGranteeGrantsRequest, QueryGranteeGrantsResponse } from "./query";
-export const createGetGrants = (getRpcInstance: RpcResolver) => buildQuery<QueryGrantsRequest, QueryGrantsResponse>({
+export const createGetGrants = (clientResolver: RpcResolver) => buildQuery<QueryGrantsRequest, QueryGrantsResponse>({
   encode: QueryGrantsRequest.encode,
   decode: QueryGrantsResponse.decode,
   service: "cosmos.authz.v1beta1.Query",
   method: "Grants",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGrants = buildUseQuery<QueryGrantsRequest, QueryGrantsResponse>({
   builderQueryFn: createGetGrants,
   queryKeyPrefix: "GrantsQuery"
 });
-export const createGetGranterGrants = (getRpcInstance: RpcResolver) => buildQuery<QueryGranterGrantsRequest, QueryGranterGrantsResponse>({
+export const createGetGranterGrants = (clientResolver: RpcResolver) => buildQuery<QueryGranterGrantsRequest, QueryGranterGrantsResponse>({
   encode: QueryGranterGrantsRequest.encode,
   decode: QueryGranterGrantsResponse.decode,
   service: "cosmos.authz.v1beta1.Query",
   method: "GranterGrants",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGranterGrants = buildUseQuery<QueryGranterGrantsRequest, QueryGranterGrantsResponse>({
   builderQueryFn: createGetGranterGrants,
   queryKeyPrefix: "GranterGrantsQuery"
 });
-export const createGetGranteeGrants = (getRpcInstance: RpcResolver) => buildQuery<QueryGranteeGrantsRequest, QueryGranteeGrantsResponse>({
+export const createGetGranteeGrants = (clientResolver: RpcResolver) => buildQuery<QueryGranteeGrantsRequest, QueryGranteeGrantsResponse>({
   encode: QueryGranteeGrantsRequest.encode,
   decode: QueryGranteeGrantsResponse.decode,
   service: "cosmos.authz.v1beta1.Query",
   method: "GranteeGrants",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGranteeGrants = buildUseQuery<QueryGranteeGrantsRequest, QueryGranteeGrantsResponse>({
   builderQueryFn: createGetGranteeGrants,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/tx.rpc.func.ts
index 878d02262..29a22be27 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/authz/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/query.rpc.func.ts
index 5f2b9c6ae..4b2941fa4 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/query.rpc.func.ts
@@ -1,100 +1,100 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryBalanceRequest, QueryBalanceResponse, QueryAllBalancesRequest, QueryAllBalancesResponse, QuerySpendableBalancesRequest, QuerySpendableBalancesResponse, QueryTotalSupplyRequest, QueryTotalSupplyResponse, QuerySupplyOfRequest, QuerySupplyOfResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomsMetadataRequest, QueryDenomsMetadataResponse, QueryDenomOwnersRequest, QueryDenomOwnersResponse } 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
 });
 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 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 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,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/tx.rpc.func.ts
index b3ba5e957..7fe816f7a 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/bank/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } from "./tx";
-export const createSend = (getSigningClient: SigningClientResolver) => buildTx<MsgSend>({
-  getSigningClient: getSigningClient,
+export const createSend = (clientResolver: SigningClientResolver) => buildTx<MsgSend>({
+  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)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v1beta1/reflection.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v1beta1/reflection.rpc.func.ts
index 9e4418276..d59c0f6eb 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v1beta1/reflection.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v1beta1/reflection.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { ListAllInterfacesRequest, ListAllInterfacesResponse, ListImplementationsRequest, ListImplementationsResponse } from "./reflection";
-export const createGetListAllInterfaces = (getRpcInstance: RpcResolver) => buildQuery<ListAllInterfacesRequest, ListAllInterfacesResponse>({
+export const createGetListAllInterfaces = (clientResolver: RpcResolver) => buildQuery<ListAllInterfacesRequest, ListAllInterfacesResponse>({
   encode: ListAllInterfacesRequest.encode,
   decode: ListAllInterfacesResponse.decode,
   service: "cosmos.base.reflection.v1beta1.ReflectionService",
   method: "ListAllInterfaces",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetListAllInterfaces = buildUseQuery<ListAllInterfacesRequest, ListAllInterfacesResponse>({
   builderQueryFn: createGetListAllInterfaces,
   queryKeyPrefix: "ListAllInterfacesQuery"
 });
-export const createGetListImplementations = (getRpcInstance: RpcResolver) => buildQuery<ListImplementationsRequest, ListImplementationsResponse>({
+export const createGetListImplementations = (clientResolver: RpcResolver) => buildQuery<ListImplementationsRequest, ListImplementationsResponse>({
   encode: ListImplementationsRequest.encode,
   decode: ListImplementationsResponse.decode,
   service: "cosmos.base.reflection.v1beta1.ReflectionService",
   method: "ListImplementations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetListImplementations = buildUseQuery<ListImplementationsRequest, ListImplementationsResponse>({
   builderQueryFn: createGetListImplementations,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v2alpha1/reflection.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v2alpha1/reflection.rpc.func.ts
index a767a3119..d1b78f3b1 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v2alpha1/reflection.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/base/reflection/v2alpha1/reflection.rpc.func.ts
@@ -1,67 +1,67 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { GetAuthnDescriptorRequest, GetAuthnDescriptorResponse, GetChainDescriptorRequest, GetChainDescriptorResponse, GetCodecDescriptorRequest, GetCodecDescriptorResponse, GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse, GetQueryServicesDescriptorRequest, GetQueryServicesDescriptorResponse, GetTxDescriptorRequest, GetTxDescriptorResponse } from "./reflection";
-export const createGetGetAuthnDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetAuthnDescriptorRequest, GetAuthnDescriptorResponse>({
+export const createGetGetAuthnDescriptor = (clientResolver: RpcResolver) => buildQuery<GetAuthnDescriptorRequest, GetAuthnDescriptorResponse>({
   encode: GetAuthnDescriptorRequest.encode,
   decode: GetAuthnDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetAuthnDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetAuthnDescriptor = buildUseQuery<GetAuthnDescriptorRequest, GetAuthnDescriptorResponse>({
   builderQueryFn: createGetGetAuthnDescriptor,
   queryKeyPrefix: "GetAuthnDescriptorQuery"
 });
-export const createGetGetChainDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetChainDescriptorRequest, GetChainDescriptorResponse>({
+export const createGetGetChainDescriptor = (clientResolver: RpcResolver) => buildQuery<GetChainDescriptorRequest, GetChainDescriptorResponse>({
   encode: GetChainDescriptorRequest.encode,
   decode: GetChainDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetChainDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetChainDescriptor = buildUseQuery<GetChainDescriptorRequest, GetChainDescriptorResponse>({
   builderQueryFn: createGetGetChainDescriptor,
   queryKeyPrefix: "GetChainDescriptorQuery"
 });
-export const createGetGetCodecDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetCodecDescriptorRequest, GetCodecDescriptorResponse>({
+export const createGetGetCodecDescriptor = (clientResolver: RpcResolver) => buildQuery<GetCodecDescriptorRequest, GetCodecDescriptorResponse>({
   encode: GetCodecDescriptorRequest.encode,
   decode: GetCodecDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetCodecDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetCodecDescriptor = buildUseQuery<GetCodecDescriptorRequest, GetCodecDescriptorResponse>({
   builderQueryFn: createGetGetCodecDescriptor,
   queryKeyPrefix: "GetCodecDescriptorQuery"
 });
-export const createGetGetConfigurationDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse>({
+export const createGetGetConfigurationDescriptor = (clientResolver: RpcResolver) => buildQuery<GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse>({
   encode: GetConfigurationDescriptorRequest.encode,
   decode: GetConfigurationDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetConfigurationDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetConfigurationDescriptor = buildUseQuery<GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse>({
   builderQueryFn: createGetGetConfigurationDescriptor,
   queryKeyPrefix: "GetConfigurationDescriptorQuery"
 });
-export const createGetGetQueryServicesDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetQueryServicesDescriptorRequest, GetQueryServicesDescriptorResponse>({
+export const createGetGetQueryServicesDescriptor = (clientResolver: RpcResolver) => buildQuery<GetQueryServicesDescriptorRequest, GetQueryServicesDescriptorResponse>({
   encode: GetQueryServicesDescriptorRequest.encode,
   decode: GetQueryServicesDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetQueryServicesDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetQueryServicesDescriptor = buildUseQuery<GetQueryServicesDescriptorRequest, GetQueryServicesDescriptorResponse>({
   builderQueryFn: createGetGetQueryServicesDescriptor,
   queryKeyPrefix: "GetQueryServicesDescriptorQuery"
 });
-export const createGetGetTxDescriptor = (getRpcInstance: RpcResolver) => buildQuery<GetTxDescriptorRequest, GetTxDescriptorResponse>({
+export const createGetGetTxDescriptor = (clientResolver: RpcResolver) => buildQuery<GetTxDescriptorRequest, GetTxDescriptorResponse>({
   encode: GetTxDescriptorRequest.encode,
   decode: GetTxDescriptorResponse.decode,
   service: "cosmos.base.reflection.v2alpha1.ReflectionService",
   method: "GetTxDescriptor",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetTxDescriptor = buildUseQuery<GetTxDescriptorRequest, GetTxDescriptorResponse>({
   builderQueryFn: createGetGetTxDescriptor,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/base/tendermint/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/base/tendermint/v1beta1/query.rpc.func.ts
index 6494808ba..222254776 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/base/tendermint/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/base/tendermint/v1beta1/query.rpc.func.ts
@@ -1,67 +1,67 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { GetNodeInfoRequest, GetNodeInfoResponse, GetSyncingRequest, GetSyncingResponse, GetLatestBlockRequest, GetLatestBlockResponse, GetBlockByHeightRequest, GetBlockByHeightResponse, GetLatestValidatorSetRequest, GetLatestValidatorSetResponse, GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponse } from "./query";
-export const createGetGetNodeInfo = (getRpcInstance: RpcResolver) => buildQuery<GetNodeInfoRequest, GetNodeInfoResponse>({
+export const createGetGetNodeInfo = (clientResolver: RpcResolver) => buildQuery<GetNodeInfoRequest, GetNodeInfoResponse>({
   encode: GetNodeInfoRequest.encode,
   decode: GetNodeInfoResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetNodeInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetNodeInfo = buildUseQuery<GetNodeInfoRequest, GetNodeInfoResponse>({
   builderQueryFn: createGetGetNodeInfo,
   queryKeyPrefix: "GetNodeInfoQuery"
 });
-export const createGetGetSyncing = (getRpcInstance: RpcResolver) => buildQuery<GetSyncingRequest, GetSyncingResponse>({
+export const createGetGetSyncing = (clientResolver: RpcResolver) => buildQuery<GetSyncingRequest, GetSyncingResponse>({
   encode: GetSyncingRequest.encode,
   decode: GetSyncingResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetSyncing",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetSyncing = buildUseQuery<GetSyncingRequest, GetSyncingResponse>({
   builderQueryFn: createGetGetSyncing,
   queryKeyPrefix: "GetSyncingQuery"
 });
-export const createGetGetLatestBlock = (getRpcInstance: RpcResolver) => buildQuery<GetLatestBlockRequest, GetLatestBlockResponse>({
+export const createGetGetLatestBlock = (clientResolver: RpcResolver) => buildQuery<GetLatestBlockRequest, GetLatestBlockResponse>({
   encode: GetLatestBlockRequest.encode,
   decode: GetLatestBlockResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetLatestBlock",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetLatestBlock = buildUseQuery<GetLatestBlockRequest, GetLatestBlockResponse>({
   builderQueryFn: createGetGetLatestBlock,
   queryKeyPrefix: "GetLatestBlockQuery"
 });
-export const createGetGetBlockByHeight = (getRpcInstance: RpcResolver) => buildQuery<GetBlockByHeightRequest, GetBlockByHeightResponse>({
+export const createGetGetBlockByHeight = (clientResolver: RpcResolver) => buildQuery<GetBlockByHeightRequest, GetBlockByHeightResponse>({
   encode: GetBlockByHeightRequest.encode,
   decode: GetBlockByHeightResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetBlockByHeight",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetBlockByHeight = buildUseQuery<GetBlockByHeightRequest, GetBlockByHeightResponse>({
   builderQueryFn: createGetGetBlockByHeight,
   queryKeyPrefix: "GetBlockByHeightQuery"
 });
-export const createGetGetLatestValidatorSet = (getRpcInstance: RpcResolver) => buildQuery<GetLatestValidatorSetRequest, GetLatestValidatorSetResponse>({
+export const createGetGetLatestValidatorSet = (clientResolver: RpcResolver) => buildQuery<GetLatestValidatorSetRequest, GetLatestValidatorSetResponse>({
   encode: GetLatestValidatorSetRequest.encode,
   decode: GetLatestValidatorSetResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetLatestValidatorSet",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetLatestValidatorSet = buildUseQuery<GetLatestValidatorSetRequest, GetLatestValidatorSetResponse>({
   builderQueryFn: createGetGetLatestValidatorSet,
   queryKeyPrefix: "GetLatestValidatorSetQuery"
 });
-export const createGetGetValidatorSetByHeight = (getRpcInstance: RpcResolver) => buildQuery<GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponse>({
+export const createGetGetValidatorSetByHeight = (clientResolver: RpcResolver) => buildQuery<GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponse>({
   encode: GetValidatorSetByHeightRequest.encode,
   decode: GetValidatorSetByHeightResponse.decode,
   service: "cosmos.base.tendermint.v1beta1.Service",
   method: "GetValidatorSetByHeight",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGetValidatorSetByHeight = buildUseQuery<GetValidatorSetByHeightRequest, GetValidatorSetByHeightResponse>({
   builderQueryFn: createGetGetValidatorSetByHeight,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/crisis/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/crisis/v1beta1/tx.rpc.func.ts
index c02e19db9..1e35e5012 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/crisis/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/crisis/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 { MsgVerifyInvariant } from "./tx";
-export const createVerifyInvariant = (getSigningClient: SigningClientResolver) => buildTx<MsgVerifyInvariant>({
-  getSigningClient: getSigningClient,
+export const createVerifyInvariant = (clientResolver: SigningClientResolver) => buildTx<MsgVerifyInvariant>({
+  clientResolver,
   typeUrl: MsgVerifyInvariant.typeUrl,
   encoders: toEncoders(MsgVerifyInvariant),
   converters: toConverters(MsgVerifyInvariant)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/query.rpc.func.ts
index 52eeee24b..27f0cb8e9 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/query.rpc.func.ts
@@ -1,100 +1,100 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponse, QueryValidatorCommissionRequest, QueryValidatorCommissionResponse, QueryValidatorSlashesRequest, QueryValidatorSlashesResponse, QueryDelegationRewardsRequest, QueryDelegationRewardsResponse, QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponse, QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse, QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponse, QueryCommunityPoolRequest, QueryCommunityPoolResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetValidatorOutstandingRewards = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponse>({
+export const createGetValidatorOutstandingRewards = (clientResolver: RpcResolver) => buildQuery<QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponse>({
   encode: QueryValidatorOutstandingRewardsRequest.encode,
   decode: QueryValidatorOutstandingRewardsResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "ValidatorOutstandingRewards",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidatorOutstandingRewards = buildUseQuery<QueryValidatorOutstandingRewardsRequest, QueryValidatorOutstandingRewardsResponse>({
   builderQueryFn: createGetValidatorOutstandingRewards,
   queryKeyPrefix: "ValidatorOutstandingRewardsQuery"
 });
-export const createGetValidatorCommission = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorCommissionRequest, QueryValidatorCommissionResponse>({
+export const createGetValidatorCommission = (clientResolver: RpcResolver) => buildQuery<QueryValidatorCommissionRequest, QueryValidatorCommissionResponse>({
   encode: QueryValidatorCommissionRequest.encode,
   decode: QueryValidatorCommissionResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "ValidatorCommission",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidatorCommission = buildUseQuery<QueryValidatorCommissionRequest, QueryValidatorCommissionResponse>({
   builderQueryFn: createGetValidatorCommission,
   queryKeyPrefix: "ValidatorCommissionQuery"
 });
-export const createGetValidatorSlashes = (getRpcInstance: RpcResolver) => buildQuery<QueryValidatorSlashesRequest, QueryValidatorSlashesResponse>({
+export const createGetValidatorSlashes = (clientResolver: RpcResolver) => buildQuery<QueryValidatorSlashesRequest, QueryValidatorSlashesResponse>({
   encode: QueryValidatorSlashesRequest.encode,
   decode: QueryValidatorSlashesResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "ValidatorSlashes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetValidatorSlashes = buildUseQuery<QueryValidatorSlashesRequest, QueryValidatorSlashesResponse>({
   builderQueryFn: createGetValidatorSlashes,
   queryKeyPrefix: "ValidatorSlashesQuery"
 });
-export const createGetDelegationRewards = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegationRewardsRequest, QueryDelegationRewardsResponse>({
+export const createGetDelegationRewards = (clientResolver: RpcResolver) => buildQuery<QueryDelegationRewardsRequest, QueryDelegationRewardsResponse>({
   encode: QueryDelegationRewardsRequest.encode,
   decode: QueryDelegationRewardsResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "DelegationRewards",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegationRewards = buildUseQuery<QueryDelegationRewardsRequest, QueryDelegationRewardsResponse>({
   builderQueryFn: createGetDelegationRewards,
   queryKeyPrefix: "DelegationRewardsQuery"
 });
-export const createGetDelegationTotalRewards = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponse>({
+export const createGetDelegationTotalRewards = (clientResolver: RpcResolver) => buildQuery<QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponse>({
   encode: QueryDelegationTotalRewardsRequest.encode,
   decode: QueryDelegationTotalRewardsResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "DelegationTotalRewards",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegationTotalRewards = buildUseQuery<QueryDelegationTotalRewardsRequest, QueryDelegationTotalRewardsResponse>({
   builderQueryFn: createGetDelegationTotalRewards,
   queryKeyPrefix: "DelegationTotalRewardsQuery"
 });
-export const createGetDelegatorValidators = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
+export const createGetDelegatorValidators = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
   encode: QueryDelegatorValidatorsRequest.encode,
   decode: QueryDelegatorValidatorsResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "DelegatorValidators",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorValidators = buildUseQuery<QueryDelegatorValidatorsRequest, QueryDelegatorValidatorsResponse>({
   builderQueryFn: createGetDelegatorValidators,
   queryKeyPrefix: "DelegatorValidatorsQuery"
 });
-export const createGetDelegatorWithdrawAddress = (getRpcInstance: RpcResolver) => buildQuery<QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponse>({
+export const createGetDelegatorWithdrawAddress = (clientResolver: RpcResolver) => buildQuery<QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponse>({
   encode: QueryDelegatorWithdrawAddressRequest.encode,
   decode: QueryDelegatorWithdrawAddressResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "DelegatorWithdrawAddress",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDelegatorWithdrawAddress = buildUseQuery<QueryDelegatorWithdrawAddressRequest, QueryDelegatorWithdrawAddressResponse>({
   builderQueryFn: createGetDelegatorWithdrawAddress,
   queryKeyPrefix: "DelegatorWithdrawAddressQuery"
 });
-export const createGetCommunityPool = (getRpcInstance: RpcResolver) => buildQuery<QueryCommunityPoolRequest, QueryCommunityPoolResponse>({
+export const createGetCommunityPool = (clientResolver: RpcResolver) => buildQuery<QueryCommunityPoolRequest, QueryCommunityPoolResponse>({
   encode: QueryCommunityPoolRequest.encode,
   decode: QueryCommunityPoolResponse.decode,
   service: "cosmos.distribution.v1beta1.Query",
   method: "CommunityPool",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCommunityPool = buildUseQuery<QueryCommunityPoolRequest, QueryCommunityPoolResponse>({
   builderQueryFn: createGetCommunityPool,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/tx.rpc.func.ts
index 884c3faf6..9fa0c3a25 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/distribution/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/query.rpc.func.ts
index 94dd0c7dc..ac686d264 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryEvidenceRequest, QueryEvidenceResponse, QueryAllEvidenceRequest, QueryAllEvidenceResponse } from "./query";
-export const createGetEvidence = (getRpcInstance: RpcResolver) => buildQuery<QueryEvidenceRequest, QueryEvidenceResponse>({
+export const createGetEvidence = (clientResolver: RpcResolver) => buildQuery<QueryEvidenceRequest, QueryEvidenceResponse>({
   encode: QueryEvidenceRequest.encode,
   decode: QueryEvidenceResponse.decode,
   service: "cosmos.evidence.v1beta1.Query",
   method: "Evidence",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEvidence = buildUseQuery<QueryEvidenceRequest, QueryEvidenceResponse>({
   builderQueryFn: createGetEvidence,
   queryKeyPrefix: "EvidenceQuery"
 });
-export const createGetAllEvidence = (getRpcInstance: RpcResolver) => buildQuery<QueryAllEvidenceRequest, QueryAllEvidenceResponse>({
+export const createGetAllEvidence = (clientResolver: RpcResolver) => buildQuery<QueryAllEvidenceRequest, QueryAllEvidenceResponse>({
   encode: QueryAllEvidenceRequest.encode,
   decode: QueryAllEvidenceResponse.decode,
   service: "cosmos.evidence.v1beta1.Query",
   method: "AllEvidence",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllEvidence = buildUseQuery<QueryAllEvidenceRequest, QueryAllEvidenceResponse>({
   builderQueryFn: createGetAllEvidence,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/tx.rpc.func.ts
index 2d622b6e9..f38641481 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/evidence/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/evidence/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 { MsgSubmitEvidence } from "./tx";
-export const createSubmitEvidence = (getSigningClient: SigningClientResolver) => buildTx<MsgSubmitEvidence>({
-  getSigningClient: getSigningClient,
+export const createSubmitEvidence = (clientResolver: SigningClientResolver) => buildTx<MsgSubmitEvidence>({
+  clientResolver,
   typeUrl: MsgSubmitEvidence.typeUrl,
   encoders: toEncoders(MsgSubmitEvidence),
   converters: toConverters(MsgSubmitEvidence)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/query.rpc.func.ts
index a4bb5dfa1..9381851e1 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryAllowanceRequest, QueryAllowanceResponse, QueryAllowancesRequest, QueryAllowancesResponse, QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponse } from "./query";
-export const createGetAllowance = (getRpcInstance: RpcResolver) => buildQuery<QueryAllowanceRequest, QueryAllowanceResponse>({
+export const createGetAllowance = (clientResolver: RpcResolver) => buildQuery<QueryAllowanceRequest, QueryAllowanceResponse>({
   encode: QueryAllowanceRequest.encode,
   decode: QueryAllowanceResponse.decode,
   service: "cosmos.feegrant.v1beta1.Query",
   method: "Allowance",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllowance = buildUseQuery<QueryAllowanceRequest, QueryAllowanceResponse>({
   builderQueryFn: createGetAllowance,
   queryKeyPrefix: "AllowanceQuery"
 });
-export const createGetAllowances = (getRpcInstance: RpcResolver) => buildQuery<QueryAllowancesRequest, QueryAllowancesResponse>({
+export const createGetAllowances = (clientResolver: RpcResolver) => buildQuery<QueryAllowancesRequest, QueryAllowancesResponse>({
   encode: QueryAllowancesRequest.encode,
   decode: QueryAllowancesResponse.decode,
   service: "cosmos.feegrant.v1beta1.Query",
   method: "Allowances",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllowances = buildUseQuery<QueryAllowancesRequest, QueryAllowancesResponse>({
   builderQueryFn: createGetAllowances,
   queryKeyPrefix: "AllowancesQuery"
 });
-export const createGetAllowancesByGranter = (getRpcInstance: RpcResolver) => buildQuery<QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponse>({
+export const createGetAllowancesByGranter = (clientResolver: RpcResolver) => buildQuery<QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponse>({
   encode: QueryAllowancesByGranterRequest.encode,
   decode: QueryAllowancesByGranterResponse.decode,
   service: "cosmos.feegrant.v1beta1.Query",
   method: "AllowancesByGranter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllowancesByGranter = buildUseQuery<QueryAllowancesByGranterRequest, QueryAllowancesByGranterResponse>({
   builderQueryFn: createGetAllowancesByGranter,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/tx.rpc.func.ts
index c384d58e7..b7a35d430 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/feegrant/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/gov/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/gov/v1/query.rpc.func.ts
index e53c5f768..8705e2971 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/gov/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/gov/v1/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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.Query",
   method: "TallyResult",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTallyResult = buildUseQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
   builderQueryFn: createGetTallyResult,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/gov/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/gov/v1/tx.rpc.func.ts
index 2f5b5a68c..5dc327c32 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/gov/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/query.rpc.func.ts
index 5eaf75468..3230a3a63 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/tx.rpc.func.ts
index f5034e448..f4a80fbd9 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/gov/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmos/group/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/group/v1/query.rpc.func.ts
index 95b1c3efc..68ef38c03 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/group/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/group/v1/query.rpc.func.ts
@@ -1,144 +1,144 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryGroupInfoRequest, QueryGroupInfoResponse, QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse, QueryGroupMembersRequest, QueryGroupMembersResponse, QueryGroupsByAdminRequest, QueryGroupsByAdminResponse, QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse, QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse, QueryProposalRequest, QueryProposalResponse, QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse, QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse, QueryVotesByProposalRequest, QueryVotesByProposalResponse, QueryVotesByVoterRequest, QueryVotesByVoterResponse, QueryGroupsByMemberRequest, QueryGroupsByMemberResponse, QueryTallyResultRequest, QueryTallyResultResponse } from "./query";
-export const createGetGroupInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupInfoRequest, QueryGroupInfoResponse>({
+export const createGetGroupInfo = (clientResolver: RpcResolver) => buildQuery<QueryGroupInfoRequest, QueryGroupInfoResponse>({
   encode: QueryGroupInfoRequest.encode,
   decode: QueryGroupInfoResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupInfo = buildUseQuery<QueryGroupInfoRequest, QueryGroupInfoResponse>({
   builderQueryFn: createGetGroupInfo,
   queryKeyPrefix: "GroupInfoQuery"
 });
-export const createGetGroupPolicyInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse>({
+export const createGetGroupPolicyInfo = (clientResolver: RpcResolver) => buildQuery<QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse>({
   encode: QueryGroupPolicyInfoRequest.encode,
   decode: QueryGroupPolicyInfoResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupPolicyInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupPolicyInfo = buildUseQuery<QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse>({
   builderQueryFn: createGetGroupPolicyInfo,
   queryKeyPrefix: "GroupPolicyInfoQuery"
 });
-export const createGetGroupMembers = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupMembersRequest, QueryGroupMembersResponse>({
+export const createGetGroupMembers = (clientResolver: RpcResolver) => buildQuery<QueryGroupMembersRequest, QueryGroupMembersResponse>({
   encode: QueryGroupMembersRequest.encode,
   decode: QueryGroupMembersResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupMembers",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupMembers = buildUseQuery<QueryGroupMembersRequest, QueryGroupMembersResponse>({
   builderQueryFn: createGetGroupMembers,
   queryKeyPrefix: "GroupMembersQuery"
 });
-export const createGetGroupsByAdmin = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupsByAdminRequest, QueryGroupsByAdminResponse>({
+export const createGetGroupsByAdmin = (clientResolver: RpcResolver) => buildQuery<QueryGroupsByAdminRequest, QueryGroupsByAdminResponse>({
   encode: QueryGroupsByAdminRequest.encode,
   decode: QueryGroupsByAdminResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupsByAdmin",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupsByAdmin = buildUseQuery<QueryGroupsByAdminRequest, QueryGroupsByAdminResponse>({
   builderQueryFn: createGetGroupsByAdmin,
   queryKeyPrefix: "GroupsByAdminQuery"
 });
-export const createGetGroupPoliciesByGroup = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse>({
+export const createGetGroupPoliciesByGroup = (clientResolver: RpcResolver) => buildQuery<QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse>({
   encode: QueryGroupPoliciesByGroupRequest.encode,
   decode: QueryGroupPoliciesByGroupResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupPoliciesByGroup",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupPoliciesByGroup = buildUseQuery<QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse>({
   builderQueryFn: createGetGroupPoliciesByGroup,
   queryKeyPrefix: "GroupPoliciesByGroupQuery"
 });
-export const createGetGroupPoliciesByAdmin = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse>({
+export const createGetGroupPoliciesByAdmin = (clientResolver: RpcResolver) => buildQuery<QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse>({
   encode: QueryGroupPoliciesByAdminRequest.encode,
   decode: QueryGroupPoliciesByAdminResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupPoliciesByAdmin",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupPoliciesByAdmin = buildUseQuery<QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse>({
   builderQueryFn: createGetGroupPoliciesByAdmin,
   queryKeyPrefix: "GroupPoliciesByAdminQuery"
 });
-export const createGetProposal = (getRpcInstance: RpcResolver) => buildQuery<QueryProposalRequest, QueryProposalResponse>({
+export const createGetProposal = (clientResolver: RpcResolver) => buildQuery<QueryProposalRequest, QueryProposalResponse>({
   encode: QueryProposalRequest.encode,
   decode: QueryProposalResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "Proposal",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProposal = buildUseQuery<QueryProposalRequest, QueryProposalResponse>({
   builderQueryFn: createGetProposal,
   queryKeyPrefix: "ProposalQuery"
 });
-export const createGetProposalsByGroupPolicy = (getRpcInstance: RpcResolver) => buildQuery<QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse>({
+export const createGetProposalsByGroupPolicy = (clientResolver: RpcResolver) => buildQuery<QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse>({
   encode: QueryProposalsByGroupPolicyRequest.encode,
   decode: QueryProposalsByGroupPolicyResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "ProposalsByGroupPolicy",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetProposalsByGroupPolicy = buildUseQuery<QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse>({
   builderQueryFn: createGetProposalsByGroupPolicy,
   queryKeyPrefix: "ProposalsByGroupPolicyQuery"
 });
-export const createGetVoteByProposalVoter = (getRpcInstance: RpcResolver) => buildQuery<QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse>({
+export const createGetVoteByProposalVoter = (clientResolver: RpcResolver) => buildQuery<QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse>({
   encode: QueryVoteByProposalVoterRequest.encode,
   decode: QueryVoteByProposalVoterResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "VoteByProposalVoter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetVoteByProposalVoter = buildUseQuery<QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse>({
   builderQueryFn: createGetVoteByProposalVoter,
   queryKeyPrefix: "VoteByProposalVoterQuery"
 });
-export const createGetVotesByProposal = (getRpcInstance: RpcResolver) => buildQuery<QueryVotesByProposalRequest, QueryVotesByProposalResponse>({
+export const createGetVotesByProposal = (clientResolver: RpcResolver) => buildQuery<QueryVotesByProposalRequest, QueryVotesByProposalResponse>({
   encode: QueryVotesByProposalRequest.encode,
   decode: QueryVotesByProposalResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "VotesByProposal",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetVotesByProposal = buildUseQuery<QueryVotesByProposalRequest, QueryVotesByProposalResponse>({
   builderQueryFn: createGetVotesByProposal,
   queryKeyPrefix: "VotesByProposalQuery"
 });
-export const createGetVotesByVoter = (getRpcInstance: RpcResolver) => buildQuery<QueryVotesByVoterRequest, QueryVotesByVoterResponse>({
+export const createGetVotesByVoter = (clientResolver: RpcResolver) => buildQuery<QueryVotesByVoterRequest, QueryVotesByVoterResponse>({
   encode: QueryVotesByVoterRequest.encode,
   decode: QueryVotesByVoterResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "VotesByVoter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetVotesByVoter = buildUseQuery<QueryVotesByVoterRequest, QueryVotesByVoterResponse>({
   builderQueryFn: createGetVotesByVoter,
   queryKeyPrefix: "VotesByVoterQuery"
 });
-export const createGetGroupsByMember = (getRpcInstance: RpcResolver) => buildQuery<QueryGroupsByMemberRequest, QueryGroupsByMemberResponse>({
+export const createGetGroupsByMember = (clientResolver: RpcResolver) => buildQuery<QueryGroupsByMemberRequest, QueryGroupsByMemberResponse>({
   encode: QueryGroupsByMemberRequest.encode,
   decode: QueryGroupsByMemberResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "GroupsByMember",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGroupsByMember = buildUseQuery<QueryGroupsByMemberRequest, QueryGroupsByMemberResponse>({
   builderQueryFn: createGetGroupsByMember,
   queryKeyPrefix: "GroupsByMemberQuery"
 });
-export const createGetTallyResult = (getRpcInstance: RpcResolver) => buildQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
+export const createGetTallyResult = (clientResolver: RpcResolver) => buildQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
   encode: QueryTallyResultRequest.encode,
   decode: QueryTallyResultResponse.decode,
   service: "cosmos.group.v1.Query",
   method: "TallyResult",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTallyResult = buildUseQuery<QueryTallyResultRequest, QueryTallyResultResponse>({
   builderQueryFn: createGetTallyResult,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/group/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/group/v1/tx.rpc.func.ts
index 82fab8b30..59f3e30e4 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/group/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmos/mint/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/mint/v1beta1/query.rpc.func.ts
index 90b30fdc1..9e40c8450 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/mint/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/mint/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QueryInflationRequest, QueryInflationResponse, QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.mint.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetInflation = (getRpcInstance: RpcResolver) => buildQuery<QueryInflationRequest, QueryInflationResponse>({
+export const createGetInflation = (clientResolver: RpcResolver) => buildQuery<QueryInflationRequest, QueryInflationResponse>({
   encode: QueryInflationRequest.encode,
   decode: QueryInflationResponse.decode,
   service: "cosmos.mint.v1beta1.Query",
   method: "Inflation",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetInflation = buildUseQuery<QueryInflationRequest, QueryInflationResponse>({
   builderQueryFn: createGetInflation,
   queryKeyPrefix: "InflationQuery"
 });
-export const createGetAnnualProvisions = (getRpcInstance: RpcResolver) => buildQuery<QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse>({
+export const createGetAnnualProvisions = (clientResolver: RpcResolver) => buildQuery<QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse>({
   encode: QueryAnnualProvisionsRequest.encode,
   decode: QueryAnnualProvisionsResponse.decode,
   service: "cosmos.mint.v1beta1.Query",
   method: "AnnualProvisions",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAnnualProvisions = buildUseQuery<QueryAnnualProvisionsRequest, QueryAnnualProvisionsResponse>({
   builderQueryFn: createGetAnnualProvisions,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/query.rpc.func.ts
index 06f85a2e8..d4cb6b436 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/query.rpc.func.ts
@@ -1,78 +1,78 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryBalanceRequest, QueryBalanceResponse, QueryOwnerRequest, QueryOwnerResponse, QuerySupplyRequest, QuerySupplyResponse, QueryNFTsRequest, QueryNFTsResponse, QueryNFTRequest, QueryNFTResponse, QueryClassRequest, QueryClassResponse, QueryClassesRequest, QueryClassesResponse } 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.nft.v1beta1.Query",
   method: "Balance",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBalance = buildUseQuery<QueryBalanceRequest, QueryBalanceResponse>({
   builderQueryFn: createGetBalance,
   queryKeyPrefix: "BalanceQuery"
 });
-export const createGetOwner = (getRpcInstance: RpcResolver) => buildQuery<QueryOwnerRequest, QueryOwnerResponse>({
+export const createGetOwner = (clientResolver: RpcResolver) => buildQuery<QueryOwnerRequest, QueryOwnerResponse>({
   encode: QueryOwnerRequest.encode,
   decode: QueryOwnerResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "Owner",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetOwner = buildUseQuery<QueryOwnerRequest, QueryOwnerResponse>({
   builderQueryFn: createGetOwner,
   queryKeyPrefix: "OwnerQuery"
 });
-export const createGetSupply = (getRpcInstance: RpcResolver) => buildQuery<QuerySupplyRequest, QuerySupplyResponse>({
+export const createGetSupply = (clientResolver: RpcResolver) => buildQuery<QuerySupplyRequest, QuerySupplyResponse>({
   encode: QuerySupplyRequest.encode,
   decode: QuerySupplyResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "Supply",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSupply = buildUseQuery<QuerySupplyRequest, QuerySupplyResponse>({
   builderQueryFn: createGetSupply,
   queryKeyPrefix: "SupplyQuery"
 });
-export const createGetNFTs = (getRpcInstance: RpcResolver) => buildQuery<QueryNFTsRequest, QueryNFTsResponse>({
+export const createGetNFTs = (clientResolver: RpcResolver) => buildQuery<QueryNFTsRequest, QueryNFTsResponse>({
   encode: QueryNFTsRequest.encode,
   decode: QueryNFTsResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "NFTs",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetNFTs = buildUseQuery<QueryNFTsRequest, QueryNFTsResponse>({
   builderQueryFn: createGetNFTs,
   queryKeyPrefix: "NFTsQuery"
 });
-export const createGetNFT = (getRpcInstance: RpcResolver) => buildQuery<QueryNFTRequest, QueryNFTResponse>({
+export const createGetNFT = (clientResolver: RpcResolver) => buildQuery<QueryNFTRequest, QueryNFTResponse>({
   encode: QueryNFTRequest.encode,
   decode: QueryNFTResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "NFT",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetNFT = buildUseQuery<QueryNFTRequest, QueryNFTResponse>({
   builderQueryFn: createGetNFT,
   queryKeyPrefix: "NFTQuery"
 });
-export const createGetClass = (getRpcInstance: RpcResolver) => buildQuery<QueryClassRequest, QueryClassResponse>({
+export const createGetClass = (clientResolver: RpcResolver) => buildQuery<QueryClassRequest, QueryClassResponse>({
   encode: QueryClassRequest.encode,
   decode: QueryClassResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "Class",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClass = buildUseQuery<QueryClassRequest, QueryClassResponse>({
   builderQueryFn: createGetClass,
   queryKeyPrefix: "ClassQuery"
 });
-export const createGetClasses = (getRpcInstance: RpcResolver) => buildQuery<QueryClassesRequest, QueryClassesResponse>({
+export const createGetClasses = (clientResolver: RpcResolver) => buildQuery<QueryClassesRequest, QueryClassesResponse>({
   encode: QueryClassesRequest.encode,
   decode: QueryClassesResponse.decode,
   service: "cosmos.nft.v1beta1.Query",
   method: "Classes",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClasses = buildUseQuery<QueryClassesRequest, QueryClassesResponse>({
   builderQueryFn: createGetClasses,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/tx.rpc.func.ts
index c2551a90e..532ea02dd 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/nft/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/nft/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 } from "./tx";
-export const createSend = (getSigningClient: SigningClientResolver) => buildTx<MsgSend>({
-  getSigningClient: getSigningClient,
+export const createSend = (clientResolver: SigningClientResolver) => buildTx<MsgSend>({
+  clientResolver,
   typeUrl: MsgSend.typeUrl,
   encoders: toEncoders(MsgSend),
   converters: toConverters(MsgSend)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/params/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/params/v1beta1/query.rpc.func.ts
index 3bf68015a..d6ba77f72 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/params/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/params/v1beta1/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QuerySubspacesRequest, QuerySubspacesResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.params.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetSubspaces = (getRpcInstance: RpcResolver) => buildQuery<QuerySubspacesRequest, QuerySubspacesResponse>({
+export const createGetSubspaces = (clientResolver: RpcResolver) => buildQuery<QuerySubspacesRequest, QuerySubspacesResponse>({
   encode: QuerySubspacesRequest.encode,
   decode: QuerySubspacesResponse.decode,
   service: "cosmos.params.v1beta1.Query",
   method: "Subspaces",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSubspaces = buildUseQuery<QuerySubspacesRequest, QuerySubspacesResponse>({
   builderQueryFn: createGetSubspaces,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/query.rpc.func.ts
index f5b43b9bc..baa018b21 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QuerySigningInfoRequest, QuerySigningInfoResponse, QuerySigningInfosRequest, QuerySigningInfosResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "cosmos.slashing.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetSigningInfo = (getRpcInstance: RpcResolver) => buildQuery<QuerySigningInfoRequest, QuerySigningInfoResponse>({
+export const createGetSigningInfo = (clientResolver: RpcResolver) => buildQuery<QuerySigningInfoRequest, QuerySigningInfoResponse>({
   encode: QuerySigningInfoRequest.encode,
   decode: QuerySigningInfoResponse.decode,
   service: "cosmos.slashing.v1beta1.Query",
   method: "SigningInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSigningInfo = buildUseQuery<QuerySigningInfoRequest, QuerySigningInfoResponse>({
   builderQueryFn: createGetSigningInfo,
   queryKeyPrefix: "SigningInfoQuery"
 });
-export const createGetSigningInfos = (getRpcInstance: RpcResolver) => buildQuery<QuerySigningInfosRequest, QuerySigningInfosResponse>({
+export const createGetSigningInfos = (clientResolver: RpcResolver) => buildQuery<QuerySigningInfosRequest, QuerySigningInfosResponse>({
   encode: QuerySigningInfosRequest.encode,
   decode: QuerySigningInfosResponse.decode,
   service: "cosmos.slashing.v1beta1.Query",
   method: "SigningInfos",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSigningInfos = buildUseQuery<QuerySigningInfosRequest, QuerySigningInfosResponse>({
   builderQueryFn: createGetSigningInfos,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/tx.rpc.func.ts
index 340afd3bd..44ec0a399 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/slashing/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/slashing/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 { MsgUnjail } from "./tx";
-export const createUnjail = (getSigningClient: SigningClientResolver) => buildTx<MsgUnjail>({
-  getSigningClient: getSigningClient,
+export const createUnjail = (clientResolver: SigningClientResolver) => buildTx<MsgUnjail>({
+  clientResolver,
   typeUrl: MsgUnjail.typeUrl,
   encoders: toEncoders(MsgUnjail),
   converters: toConverters(MsgUnjail)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/query.rpc.func.ts
index c85d8e399..e91b667b3 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/tx.rpc.func.ts
index 6e9898015..0331addaf 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/staking/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/tx/v1beta1/service.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/tx/v1beta1/service.rpc.func.ts
index b3c15a7ed..20c492721 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/tx/v1beta1/service.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/tx/v1beta1/service.rpc.func.ts
@@ -1,56 +1,56 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { SimulateRequest, SimulateResponse, GetTxRequest, GetTxResponse, BroadcastTxRequest, BroadcastTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse } 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,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/query.rpc.func.ts
index a774cb5c7..f46b5bdc2 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/query.rpc.func.ts
@@ -1,56 +1,56 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryCurrentPlanRequest, QueryCurrentPlanResponse, QueryAppliedPlanRequest, QueryAppliedPlanResponse, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse, QueryModuleVersionsRequest, QueryModuleVersionsResponse, QueryAuthorityRequest, QueryAuthorityResponse } from "./query";
-export const createGetCurrentPlan = (getRpcInstance: RpcResolver) => buildQuery<QueryCurrentPlanRequest, QueryCurrentPlanResponse>({
+export const createGetCurrentPlan = (clientResolver: RpcResolver) => buildQuery<QueryCurrentPlanRequest, QueryCurrentPlanResponse>({
   encode: QueryCurrentPlanRequest.encode,
   decode: QueryCurrentPlanResponse.decode,
   service: "cosmos.upgrade.v1beta1.Query",
   method: "CurrentPlan",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCurrentPlan = buildUseQuery<QueryCurrentPlanRequest, QueryCurrentPlanResponse>({
   builderQueryFn: createGetCurrentPlan,
   queryKeyPrefix: "CurrentPlanQuery"
 });
-export const createGetAppliedPlan = (getRpcInstance: RpcResolver) => buildQuery<QueryAppliedPlanRequest, QueryAppliedPlanResponse>({
+export const createGetAppliedPlan = (clientResolver: RpcResolver) => buildQuery<QueryAppliedPlanRequest, QueryAppliedPlanResponse>({
   encode: QueryAppliedPlanRequest.encode,
   decode: QueryAppliedPlanResponse.decode,
   service: "cosmos.upgrade.v1beta1.Query",
   method: "AppliedPlan",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAppliedPlan = buildUseQuery<QueryAppliedPlanRequest, QueryAppliedPlanResponse>({
   builderQueryFn: createGetAppliedPlan,
   queryKeyPrefix: "AppliedPlanQuery"
 });
-export const createGetUpgradedConsensusState = (getRpcInstance: RpcResolver) => buildQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
+export const createGetUpgradedConsensusState = (clientResolver: RpcResolver) => buildQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
   encode: QueryUpgradedConsensusStateRequest.encode,
   decode: QueryUpgradedConsensusStateResponse.decode,
   service: "cosmos.upgrade.v1beta1.Query",
   method: "UpgradedConsensusState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUpgradedConsensusState = buildUseQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
   builderQueryFn: createGetUpgradedConsensusState,
   queryKeyPrefix: "UpgradedConsensusStateQuery"
 });
-export const createGetModuleVersions = (getRpcInstance: RpcResolver) => buildQuery<QueryModuleVersionsRequest, QueryModuleVersionsResponse>({
+export const createGetModuleVersions = (clientResolver: RpcResolver) => buildQuery<QueryModuleVersionsRequest, QueryModuleVersionsResponse>({
   encode: QueryModuleVersionsRequest.encode,
   decode: QueryModuleVersionsResponse.decode,
   service: "cosmos.upgrade.v1beta1.Query",
   method: "ModuleVersions",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleVersions = buildUseQuery<QueryModuleVersionsRequest, QueryModuleVersionsResponse>({
   builderQueryFn: createGetModuleVersions,
   queryKeyPrefix: "ModuleVersionsQuery"
 });
-export const createGetAuthority = (getRpcInstance: RpcResolver) => buildQuery<QueryAuthorityRequest, QueryAuthorityResponse>({
+export const createGetAuthority = (clientResolver: RpcResolver) => buildQuery<QueryAuthorityRequest, QueryAuthorityResponse>({
   encode: QueryAuthorityRequest.encode,
   decode: QueryAuthorityResponse.decode,
   service: "cosmos.upgrade.v1beta1.Query",
   method: "Authority",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAuthority = buildUseQuery<QueryAuthorityRequest, QueryAuthorityResponse>({
   builderQueryFn: createGetAuthority,
diff --git a/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/tx.rpc.func.ts
index 1361e7514..837d251b0 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/upgrade/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmos/upgrade/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 { MsgSoftwareUpgrade, MsgCancelUpgrade } from "./tx";
-export const createSoftwareUpgrade = (getSigningClient: SigningClientResolver) => buildTx<MsgSoftwareUpgrade>({
-  getSigningClient: getSigningClient,
+export const createSoftwareUpgrade = (clientResolver: SigningClientResolver) => buildTx<MsgSoftwareUpgrade>({
+  clientResolver,
   typeUrl: MsgSoftwareUpgrade.typeUrl,
   encoders: toEncoders(MsgSoftwareUpgrade),
   converters: toConverters(MsgSoftwareUpgrade)
@@ -11,8 +11,8 @@ export const createSoftwareUpgrade = (getSigningClient: SigningClientResolver) =
 export const useSoftwareUpgrade = buildUseMutation<MsgSoftwareUpgrade, Error>({
   builderMutationFn: createSoftwareUpgrade
 });
-export const createCancelUpgrade = (getSigningClient: SigningClientResolver) => buildTx<MsgCancelUpgrade>({
-  getSigningClient: getSigningClient,
+export const createCancelUpgrade = (clientResolver: SigningClientResolver) => buildTx<MsgCancelUpgrade>({
+  clientResolver,
   typeUrl: MsgCancelUpgrade.typeUrl,
   encoders: toEncoders(MsgCancelUpgrade),
   converters: toConverters(MsgCancelUpgrade)
diff --git a/__fixtures__/v-next/outputicjs/cosmos/vesting/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmos/vesting/v1beta1/tx.rpc.func.ts
index 6168e11e3..b54ec88f2 100644
--- a/__fixtures__/v-next/outputicjs/cosmos/vesting/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/query.rpc.func.ts
index ba7899915..2473afb40 100644
--- a/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/query.rpc.func.ts
@@ -1,100 +1,100 @@
 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 } 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,
diff --git a/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/tx.rpc.func.ts
index caf34c57d..579889b58 100644
--- a/__fixtures__/v-next/outputicjs/cosmwasm/wasm/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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, MsgExecuteContract, MsgMigrateContract, MsgUpdateAdmin, MsgClearAdmin } 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 createExecuteContract = (getSigningClient: SigningClientResolver) => buildTx<MsgExecuteContract>({
-  getSigningClient: getSigningClient,
+export const createExecuteContract = (clientResolver: SigningClientResolver) => buildTx<MsgExecuteContract>({
+  clientResolver,
   typeUrl: MsgExecuteContract.typeUrl,
   encoders: toEncoders(MsgExecuteContract),
   converters: toConverters(MsgExecuteContract)
@@ -29,8 +29,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)
@@ -38,8 +38,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)
@@ -47,8 +47,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)
diff --git a/__fixtures__/v-next/outputicjs/evmos/claims/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/claims/v1/query.rpc.func.ts
index d7e1975e3..6a157b9ae 100644
--- a/__fixtures__/v-next/outputicjs/evmos/claims/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/claims/v1/query.rpc.func.ts
@@ -1,45 +1,45 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryTotalUnclaimedRequest, QueryTotalUnclaimedResponse, QueryParamsRequest, QueryParamsResponse, QueryClaimsRecordsRequest, QueryClaimsRecordsResponse, QueryClaimsRecordRequest, QueryClaimsRecordResponse } from "./query";
-export const createGetTotalUnclaimed = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalUnclaimedRequest, QueryTotalUnclaimedResponse>({
+export const createGetTotalUnclaimed = (clientResolver: RpcResolver) => buildQuery<QueryTotalUnclaimedRequest, QueryTotalUnclaimedResponse>({
   encode: QueryTotalUnclaimedRequest.encode,
   decode: QueryTotalUnclaimedResponse.decode,
   service: "evmos.claims.v1.Query",
   method: "TotalUnclaimed",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalUnclaimed = buildUseQuery<QueryTotalUnclaimedRequest, QueryTotalUnclaimedResponse>({
   builderQueryFn: createGetTotalUnclaimed,
   queryKeyPrefix: "TotalUnclaimedQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.claims.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetClaimsRecords = (getRpcInstance: RpcResolver) => buildQuery<QueryClaimsRecordsRequest, QueryClaimsRecordsResponse>({
+export const createGetClaimsRecords = (clientResolver: RpcResolver) => buildQuery<QueryClaimsRecordsRequest, QueryClaimsRecordsResponse>({
   encode: QueryClaimsRecordsRequest.encode,
   decode: QueryClaimsRecordsResponse.decode,
   service: "evmos.claims.v1.Query",
   method: "ClaimsRecords",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClaimsRecords = buildUseQuery<QueryClaimsRecordsRequest, QueryClaimsRecordsResponse>({
   builderQueryFn: createGetClaimsRecords,
   queryKeyPrefix: "ClaimsRecordsQuery"
 });
-export const createGetClaimsRecord = (getRpcInstance: RpcResolver) => buildQuery<QueryClaimsRecordRequest, QueryClaimsRecordResponse>({
+export const createGetClaimsRecord = (clientResolver: RpcResolver) => buildQuery<QueryClaimsRecordRequest, QueryClaimsRecordResponse>({
   encode: QueryClaimsRecordRequest.encode,
   decode: QueryClaimsRecordResponse.decode,
   service: "evmos.claims.v1.Query",
   method: "ClaimsRecord",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClaimsRecord = buildUseQuery<QueryClaimsRecordRequest, QueryClaimsRecordResponse>({
   builderQueryFn: createGetClaimsRecord,
diff --git a/__fixtures__/v-next/outputicjs/evmos/epochs/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/epochs/v1/query.rpc.func.ts
index ad4e9d19b..73d5d6358 100644
--- a/__fixtures__/v-next/outputicjs/evmos/epochs/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/epochs/v1/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryEpochsInfoRequest, QueryEpochsInfoResponse, QueryCurrentEpochRequest, QueryCurrentEpochResponse } from "./query";
-export const createGetEpochInfos = (getRpcInstance: RpcResolver) => buildQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
+export const createGetEpochInfos = (clientResolver: RpcResolver) => buildQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
   encode: QueryEpochsInfoRequest.encode,
   decode: QueryEpochsInfoResponse.decode,
   service: "evmos.epochs.v1.Query",
   method: "EpochInfos",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEpochInfos = buildUseQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
   builderQueryFn: createGetEpochInfos,
   queryKeyPrefix: "EpochInfosQuery"
 });
-export const createGetCurrentEpoch = (getRpcInstance: RpcResolver) => buildQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
+export const createGetCurrentEpoch = (clientResolver: RpcResolver) => buildQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
   encode: QueryCurrentEpochRequest.encode,
   decode: QueryCurrentEpochResponse.decode,
   service: "evmos.epochs.v1.Query",
   method: "CurrentEpoch",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCurrentEpoch = buildUseQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
   builderQueryFn: createGetCurrentEpoch,
diff --git a/__fixtures__/v-next/outputicjs/evmos/erc20/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/erc20/v1/query.rpc.func.ts
index 263f29c0d..414bf573c 100644
--- a/__fixtures__/v-next/outputicjs/evmos/erc20/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/erc20/v1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryTokenPairsRequest, QueryTokenPairsResponse, QueryTokenPairRequest, QueryTokenPairResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetTokenPairs = (getRpcInstance: RpcResolver) => buildQuery<QueryTokenPairsRequest, QueryTokenPairsResponse>({
+export const createGetTokenPairs = (clientResolver: RpcResolver) => buildQuery<QueryTokenPairsRequest, QueryTokenPairsResponse>({
   encode: QueryTokenPairsRequest.encode,
   decode: QueryTokenPairsResponse.decode,
   service: "evmos.erc20.v1.Query",
   method: "TokenPairs",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTokenPairs = buildUseQuery<QueryTokenPairsRequest, QueryTokenPairsResponse>({
   builderQueryFn: createGetTokenPairs,
   queryKeyPrefix: "TokenPairsQuery"
 });
-export const createGetTokenPair = (getRpcInstance: RpcResolver) => buildQuery<QueryTokenPairRequest, QueryTokenPairResponse>({
+export const createGetTokenPair = (clientResolver: RpcResolver) => buildQuery<QueryTokenPairRequest, QueryTokenPairResponse>({
   encode: QueryTokenPairRequest.encode,
   decode: QueryTokenPairResponse.decode,
   service: "evmos.erc20.v1.Query",
   method: "TokenPair",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTokenPair = buildUseQuery<QueryTokenPairRequest, QueryTokenPairResponse>({
   builderQueryFn: createGetTokenPair,
   queryKeyPrefix: "TokenPairQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.erc20.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/evmos/erc20/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/erc20/v1/tx.rpc.func.ts
index a9340b1e2..b05471352 100644
--- a/__fixtures__/v-next/outputicjs/evmos/erc20/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/erc20/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 { MsgConvertCoin, MsgConvertERC20 } from "./tx";
-export const createConvertCoin = (getSigningClient: SigningClientResolver) => buildTx<MsgConvertCoin>({
-  getSigningClient: getSigningClient,
+export const createConvertCoin = (clientResolver: SigningClientResolver) => buildTx<MsgConvertCoin>({
+  clientResolver,
   typeUrl: MsgConvertCoin.typeUrl,
   encoders: toEncoders(MsgConvertCoin),
   converters: toConverters(MsgConvertCoin)
@@ -11,8 +11,8 @@ export const createConvertCoin = (getSigningClient: SigningClientResolver) => bu
 export const useConvertCoin = buildUseMutation<MsgConvertCoin, Error>({
   builderMutationFn: createConvertCoin
 });
-export const createConvertERC20 = (getSigningClient: SigningClientResolver) => buildTx<MsgConvertERC20>({
-  getSigningClient: getSigningClient,
+export const createConvertERC20 = (clientResolver: SigningClientResolver) => buildTx<MsgConvertERC20>({
+  clientResolver,
   typeUrl: MsgConvertERC20.typeUrl,
   encoders: toEncoders(MsgConvertERC20),
   converters: toConverters(MsgConvertERC20)
diff --git a/__fixtures__/v-next/outputicjs/evmos/fees/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/fees/v1/query.rpc.func.ts
index abc5dfe90..816458804 100644
--- a/__fixtures__/v-next/outputicjs/evmos/fees/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/fees/v1/query.rpc.func.ts
@@ -1,45 +1,45 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryDevFeeInfosRequest, QueryDevFeeInfosResponse, QueryDevFeeInfoRequest, QueryDevFeeInfoResponse, QueryParamsRequest, QueryParamsResponse, QueryDevFeeInfosPerDeployerRequest, QueryDevFeeInfosPerDeployerResponse } from "./query";
-export const createGetDevFeeInfos = (getRpcInstance: RpcResolver) => buildQuery<QueryDevFeeInfosRequest, QueryDevFeeInfosResponse>({
+export const createGetDevFeeInfos = (clientResolver: RpcResolver) => buildQuery<QueryDevFeeInfosRequest, QueryDevFeeInfosResponse>({
   encode: QueryDevFeeInfosRequest.encode,
   decode: QueryDevFeeInfosResponse.decode,
   service: "evmos.fees.v1.Query",
   method: "DevFeeInfos",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDevFeeInfos = buildUseQuery<QueryDevFeeInfosRequest, QueryDevFeeInfosResponse>({
   builderQueryFn: createGetDevFeeInfos,
   queryKeyPrefix: "DevFeeInfosQuery"
 });
-export const createGetDevFeeInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryDevFeeInfoRequest, QueryDevFeeInfoResponse>({
+export const createGetDevFeeInfo = (clientResolver: RpcResolver) => buildQuery<QueryDevFeeInfoRequest, QueryDevFeeInfoResponse>({
   encode: QueryDevFeeInfoRequest.encode,
   decode: QueryDevFeeInfoResponse.decode,
   service: "evmos.fees.v1.Query",
   method: "DevFeeInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDevFeeInfo = buildUseQuery<QueryDevFeeInfoRequest, QueryDevFeeInfoResponse>({
   builderQueryFn: createGetDevFeeInfo,
   queryKeyPrefix: "DevFeeInfoQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.fees.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetDevFeeInfosPerDeployer = (getRpcInstance: RpcResolver) => buildQuery<QueryDevFeeInfosPerDeployerRequest, QueryDevFeeInfosPerDeployerResponse>({
+export const createGetDevFeeInfosPerDeployer = (clientResolver: RpcResolver) => buildQuery<QueryDevFeeInfosPerDeployerRequest, QueryDevFeeInfosPerDeployerResponse>({
   encode: QueryDevFeeInfosPerDeployerRequest.encode,
   decode: QueryDevFeeInfosPerDeployerResponse.decode,
   service: "evmos.fees.v1.Query",
   method: "DevFeeInfosPerDeployer",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDevFeeInfosPerDeployer = buildUseQuery<QueryDevFeeInfosPerDeployerRequest, QueryDevFeeInfosPerDeployerResponse>({
   builderQueryFn: createGetDevFeeInfosPerDeployer,
diff --git a/__fixtures__/v-next/outputicjs/evmos/fees/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/fees/v1/tx.rpc.func.ts
index 2510215af..66f201bc6 100644
--- a/__fixtures__/v-next/outputicjs/evmos/fees/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/fees/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 { MsgRegisterDevFeeInfo, MsgCancelDevFeeInfo, MsgUpdateDevFeeInfo } from "./tx";
-export const createRegisterDevFeeInfo = (getSigningClient: SigningClientResolver) => buildTx<MsgRegisterDevFeeInfo>({
-  getSigningClient: getSigningClient,
+export const createRegisterDevFeeInfo = (clientResolver: SigningClientResolver) => buildTx<MsgRegisterDevFeeInfo>({
+  clientResolver,
   typeUrl: MsgRegisterDevFeeInfo.typeUrl,
   encoders: toEncoders(MsgRegisterDevFeeInfo),
   converters: toConverters(MsgRegisterDevFeeInfo)
@@ -11,8 +11,8 @@ export const createRegisterDevFeeInfo = (getSigningClient: SigningClientResolver
 export const useRegisterDevFeeInfo = buildUseMutation<MsgRegisterDevFeeInfo, Error>({
   builderMutationFn: createRegisterDevFeeInfo
 });
-export const createCancelDevFeeInfo = (getSigningClient: SigningClientResolver) => buildTx<MsgCancelDevFeeInfo>({
-  getSigningClient: getSigningClient,
+export const createCancelDevFeeInfo = (clientResolver: SigningClientResolver) => buildTx<MsgCancelDevFeeInfo>({
+  clientResolver,
   typeUrl: MsgCancelDevFeeInfo.typeUrl,
   encoders: toEncoders(MsgCancelDevFeeInfo),
   converters: toConverters(MsgCancelDevFeeInfo)
@@ -20,8 +20,8 @@ export const createCancelDevFeeInfo = (getSigningClient: SigningClientResolver)
 export const useCancelDevFeeInfo = buildUseMutation<MsgCancelDevFeeInfo, Error>({
   builderMutationFn: createCancelDevFeeInfo
 });
-export const createUpdateDevFeeInfo = (getSigningClient: SigningClientResolver) => buildTx<MsgUpdateDevFeeInfo>({
-  getSigningClient: getSigningClient,
+export const createUpdateDevFeeInfo = (clientResolver: SigningClientResolver) => buildTx<MsgUpdateDevFeeInfo>({
+  clientResolver,
   typeUrl: MsgUpdateDevFeeInfo.typeUrl,
   encoders: toEncoders(MsgUpdateDevFeeInfo),
   converters: toConverters(MsgUpdateDevFeeInfo)
diff --git a/__fixtures__/v-next/outputicjs/evmos/incentives/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/incentives/v1/query.rpc.func.ts
index 54cba73f2..61ca944f4 100644
--- a/__fixtures__/v-next/outputicjs/evmos/incentives/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/incentives/v1/query.rpc.func.ts
@@ -1,78 +1,78 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryIncentivesRequest, QueryIncentivesResponse, QueryIncentiveRequest, QueryIncentiveResponse, QueryGasMetersRequest, QueryGasMetersResponse, QueryGasMeterRequest, QueryGasMeterResponse, QueryAllocationMetersRequest, QueryAllocationMetersResponse, QueryAllocationMeterRequest, QueryAllocationMeterResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetIncentives = (getRpcInstance: RpcResolver) => buildQuery<QueryIncentivesRequest, QueryIncentivesResponse>({
+export const createGetIncentives = (clientResolver: RpcResolver) => buildQuery<QueryIncentivesRequest, QueryIncentivesResponse>({
   encode: QueryIncentivesRequest.encode,
   decode: QueryIncentivesResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "Incentives",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetIncentives = buildUseQuery<QueryIncentivesRequest, QueryIncentivesResponse>({
   builderQueryFn: createGetIncentives,
   queryKeyPrefix: "IncentivesQuery"
 });
-export const createGetIncentive = (getRpcInstance: RpcResolver) => buildQuery<QueryIncentiveRequest, QueryIncentiveResponse>({
+export const createGetIncentive = (clientResolver: RpcResolver) => buildQuery<QueryIncentiveRequest, QueryIncentiveResponse>({
   encode: QueryIncentiveRequest.encode,
   decode: QueryIncentiveResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "Incentive",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetIncentive = buildUseQuery<QueryIncentiveRequest, QueryIncentiveResponse>({
   builderQueryFn: createGetIncentive,
   queryKeyPrefix: "IncentiveQuery"
 });
-export const createGetGasMeters = (getRpcInstance: RpcResolver) => buildQuery<QueryGasMetersRequest, QueryGasMetersResponse>({
+export const createGetGasMeters = (clientResolver: RpcResolver) => buildQuery<QueryGasMetersRequest, QueryGasMetersResponse>({
   encode: QueryGasMetersRequest.encode,
   decode: QueryGasMetersResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "GasMeters",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGasMeters = buildUseQuery<QueryGasMetersRequest, QueryGasMetersResponse>({
   builderQueryFn: createGetGasMeters,
   queryKeyPrefix: "GasMetersQuery"
 });
-export const createGetGasMeter = (getRpcInstance: RpcResolver) => buildQuery<QueryGasMeterRequest, QueryGasMeterResponse>({
+export const createGetGasMeter = (clientResolver: RpcResolver) => buildQuery<QueryGasMeterRequest, QueryGasMeterResponse>({
   encode: QueryGasMeterRequest.encode,
   decode: QueryGasMeterResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "GasMeter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGasMeter = buildUseQuery<QueryGasMeterRequest, QueryGasMeterResponse>({
   builderQueryFn: createGetGasMeter,
   queryKeyPrefix: "GasMeterQuery"
 });
-export const createGetAllocationMeters = (getRpcInstance: RpcResolver) => buildQuery<QueryAllocationMetersRequest, QueryAllocationMetersResponse>({
+export const createGetAllocationMeters = (clientResolver: RpcResolver) => buildQuery<QueryAllocationMetersRequest, QueryAllocationMetersResponse>({
   encode: QueryAllocationMetersRequest.encode,
   decode: QueryAllocationMetersResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "AllocationMeters",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllocationMeters = buildUseQuery<QueryAllocationMetersRequest, QueryAllocationMetersResponse>({
   builderQueryFn: createGetAllocationMeters,
   queryKeyPrefix: "AllocationMetersQuery"
 });
-export const createGetAllocationMeter = (getRpcInstance: RpcResolver) => buildQuery<QueryAllocationMeterRequest, QueryAllocationMeterResponse>({
+export const createGetAllocationMeter = (clientResolver: RpcResolver) => buildQuery<QueryAllocationMeterRequest, QueryAllocationMeterResponse>({
   encode: QueryAllocationMeterRequest.encode,
   decode: QueryAllocationMeterResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "AllocationMeter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllocationMeter = buildUseQuery<QueryAllocationMeterRequest, QueryAllocationMeterResponse>({
   builderQueryFn: createGetAllocationMeter,
   queryKeyPrefix: "AllocationMeterQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.incentives.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/evmos/inflation/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/inflation/v1/query.rpc.func.ts
index 255c9a922..bfaa5c40a 100644
--- a/__fixtures__/v-next/outputicjs/evmos/inflation/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/inflation/v1/query.rpc.func.ts
@@ -1,67 +1,67 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryPeriodRequest, QueryPeriodResponse, QueryEpochMintProvisionRequest, QueryEpochMintProvisionResponse, QuerySkippedEpochsRequest, QuerySkippedEpochsResponse, QueryCirculatingSupplyRequest, QueryCirculatingSupplyResponse, QueryInflationRateRequest, QueryInflationRateResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetPeriod = (getRpcInstance: RpcResolver) => buildQuery<QueryPeriodRequest, QueryPeriodResponse>({
+export const createGetPeriod = (clientResolver: RpcResolver) => buildQuery<QueryPeriodRequest, QueryPeriodResponse>({
   encode: QueryPeriodRequest.encode,
   decode: QueryPeriodResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "Period",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPeriod = buildUseQuery<QueryPeriodRequest, QueryPeriodResponse>({
   builderQueryFn: createGetPeriod,
   queryKeyPrefix: "PeriodQuery"
 });
-export const createGetEpochMintProvision = (getRpcInstance: RpcResolver) => buildQuery<QueryEpochMintProvisionRequest, QueryEpochMintProvisionResponse>({
+export const createGetEpochMintProvision = (clientResolver: RpcResolver) => buildQuery<QueryEpochMintProvisionRequest, QueryEpochMintProvisionResponse>({
   encode: QueryEpochMintProvisionRequest.encode,
   decode: QueryEpochMintProvisionResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "EpochMintProvision",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEpochMintProvision = buildUseQuery<QueryEpochMintProvisionRequest, QueryEpochMintProvisionResponse>({
   builderQueryFn: createGetEpochMintProvision,
   queryKeyPrefix: "EpochMintProvisionQuery"
 });
-export const createGetSkippedEpochs = (getRpcInstance: RpcResolver) => buildQuery<QuerySkippedEpochsRequest, QuerySkippedEpochsResponse>({
+export const createGetSkippedEpochs = (clientResolver: RpcResolver) => buildQuery<QuerySkippedEpochsRequest, QuerySkippedEpochsResponse>({
   encode: QuerySkippedEpochsRequest.encode,
   decode: QuerySkippedEpochsResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "SkippedEpochs",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSkippedEpochs = buildUseQuery<QuerySkippedEpochsRequest, QuerySkippedEpochsResponse>({
   builderQueryFn: createGetSkippedEpochs,
   queryKeyPrefix: "SkippedEpochsQuery"
 });
-export const createGetCirculatingSupply = (getRpcInstance: RpcResolver) => buildQuery<QueryCirculatingSupplyRequest, QueryCirculatingSupplyResponse>({
+export const createGetCirculatingSupply = (clientResolver: RpcResolver) => buildQuery<QueryCirculatingSupplyRequest, QueryCirculatingSupplyResponse>({
   encode: QueryCirculatingSupplyRequest.encode,
   decode: QueryCirculatingSupplyResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "CirculatingSupply",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCirculatingSupply = buildUseQuery<QueryCirculatingSupplyRequest, QueryCirculatingSupplyResponse>({
   builderQueryFn: createGetCirculatingSupply,
   queryKeyPrefix: "CirculatingSupplyQuery"
 });
-export const createGetInflationRate = (getRpcInstance: RpcResolver) => buildQuery<QueryInflationRateRequest, QueryInflationRateResponse>({
+export const createGetInflationRate = (clientResolver: RpcResolver) => buildQuery<QueryInflationRateRequest, QueryInflationRateResponse>({
   encode: QueryInflationRateRequest.encode,
   decode: QueryInflationRateResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "InflationRate",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetInflationRate = buildUseQuery<QueryInflationRateRequest, QueryInflationRateResponse>({
   builderQueryFn: createGetInflationRate,
   queryKeyPrefix: "InflationRateQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.inflation.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/evmos/recovery/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/recovery/v1/query.rpc.func.ts
index 3385aa966..1a6f9e749 100644
--- a/__fixtures__/v-next/outputicjs/evmos/recovery/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/recovery/v1/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "evmos.recovery.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/evmos/vesting/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/vesting/v1/query.rpc.func.ts
index a0f835924..259e6225d 100644
--- a/__fixtures__/v-next/outputicjs/evmos/vesting/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/vesting/v1/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryBalancesRequest, QueryBalancesResponse } from "./query";
-export const createGetBalances = (getRpcInstance: RpcResolver) => buildQuery<QueryBalancesRequest, QueryBalancesResponse>({
+export const createGetBalances = (clientResolver: RpcResolver) => buildQuery<QueryBalancesRequest, QueryBalancesResponse>({
   encode: QueryBalancesRequest.encode,
   decode: QueryBalancesResponse.decode,
   service: "evmos.vesting.v1.Query",
   method: "Balances",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBalances = buildUseQuery<QueryBalancesRequest, QueryBalancesResponse>({
   builderQueryFn: createGetBalances,
diff --git a/__fixtures__/v-next/outputicjs/evmos/vesting/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/evmos/vesting/v1/tx.rpc.func.ts
index 88a5d4ca4..4aa444761 100644
--- a/__fixtures__/v-next/outputicjs/evmos/vesting/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/evmos/vesting/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 { MsgCreateClawbackVestingAccount, MsgClawback } from "./tx";
-export const createCreateClawbackVestingAccount = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateClawbackVestingAccount>({
-  getSigningClient: getSigningClient,
+export const createCreateClawbackVestingAccount = (clientResolver: SigningClientResolver) => buildTx<MsgCreateClawbackVestingAccount>({
+  clientResolver,
   typeUrl: MsgCreateClawbackVestingAccount.typeUrl,
   encoders: toEncoders(MsgCreateClawbackVestingAccount),
   converters: toConverters(MsgCreateClawbackVestingAccount)
@@ -11,8 +11,8 @@ export const createCreateClawbackVestingAccount = (getSigningClient: SigningClie
 export const useCreateClawbackVestingAccount = buildUseMutation<MsgCreateClawbackVestingAccount, Error>({
   builderMutationFn: createCreateClawbackVestingAccount
 });
-export const createClawback = (getSigningClient: SigningClientResolver) => buildTx<MsgClawback>({
-  getSigningClient: getSigningClient,
+export const createClawback = (clientResolver: SigningClientResolver) => buildTx<MsgClawback>({
+  clientResolver,
   typeUrl: MsgClawback.typeUrl,
   encoders: toEncoders(MsgClawback),
   converters: toConverters(MsgClawback)
diff --git a/__fixtures__/v-next/outputicjs/helper-func-types.ts b/__fixtures__/v-next/outputicjs/helper-func-types.ts
index bd44fa62d..ec1132b5a 100644
--- a/__fixtures__/v-next/outputicjs/helper-func-types.ts
+++ b/__fixtures__/v-next/outputicjs/helper-func-types.ts
@@ -5,20 +5,28 @@
 */
 
 
+import { HttpEndpoint } from "@interchainjs/types";
 import { BinaryReader, BinaryWriter } from "./binary";
-import { Rpc } from "./helpers";
+import { getRpcClient } from "./extern";
+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: () => Rpc | undefined
+  clientResolver: RpcResolver
 }
 
 export function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>) {
     return async (request: TReq) => {
-      const rpc = opts.getRpcInstance();
+      let rpc: Rpc | undefined;
+
+      if(isRpc(opts.clientResolver)) {
+        rpc = opts.clientResolver;
+      } else {
+        rpc = await getRpcClient(opts.clientResolver);
+      }
 
       if (!rpc) throw new Error("Query Rpc is not initialized");
 
@@ -35,6 +43,13 @@ export interface ITxArgs<TMsg> {
   memo: string;
 }
 
+export function isISigningClient(client: unknown): client is ISigningClient {
+  return client !== null && client !== undefined
+    && typeof (client as ISigningClient).signAndBroadcast === 'function'
+    && typeof (client as ISigningClient).addConverters === 'function'
+    && typeof (client as ISigningClient).addEncoders === 'function';
+}
+
 export interface ISigningClient {
   /**
    * register converters
@@ -54,7 +69,7 @@ export interface ISigningClient {
 }
 
 export interface TxBuilderOptions {
-  getSigningClient: () => ISigningClient | undefined,
+  clientResolver: SigningClientResolver,
   typeUrl: string,
   encoders?: Encoder[],
   converters?: AminoConverter[],
@@ -67,7 +82,12 @@ export function buildTx<TMsg>(opts: TxBuilderOptions) {
     fee: StdFee | 'auto',
     memo: string
   ): Promise<DeliverTxResponse> => {
-    const client = opts.getSigningClient();
+    let client: ISigningClient | undefined;
+
+    // if opts.getSigningClient is a function, call it to get the SigningClient instance
+    if(isISigningClient(opts.clientResolver)) {
+      client = opts.clientResolver;
+    }
 
     if (!client) throw new Error("SigningClient is not initialized");
 
@@ -167,5 +187,5 @@ export interface AminoConverter {
   toAmino: (data: any) => any;
 }
 
-export type SigningClientResolver = () => ISigningClient | undefined;
-export type RpcResolver = () => Rpc | undefined;
+export type SigningClientResolver = string | HttpEndpoint | ISigningClient;
+export type RpcResolver = string | HttpEndpoint | Rpc ;
diff --git a/__fixtures__/v-next/outputicjs/helpers.ts b/__fixtures__/v-next/outputicjs/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputicjs/helpers.ts
+++ b/__fixtures__/v-next/outputicjs/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/query.rpc.func.ts
index 5f272604f..3c285a8ec 100644
--- a/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { QueryDenomTraceRequest, QueryDenomTraceResponse, QueryDenomTracesRequest, QueryDenomTracesResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetDenomTrace = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomTraceRequest, QueryDenomTraceResponse>({
+export const createGetDenomTrace = (clientResolver: RpcResolver) => buildQuery<QueryDenomTraceRequest, QueryDenomTraceResponse>({
   encode: QueryDenomTraceRequest.encode,
   decode: QueryDenomTraceResponse.decode,
   service: "ibc.applications.transfer.v1.Query",
   method: "DenomTrace",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomTrace = buildUseQuery<QueryDenomTraceRequest, QueryDenomTraceResponse>({
   builderQueryFn: createGetDenomTrace,
   queryKeyPrefix: "DenomTraceQuery"
 });
-export const createGetDenomTraces = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomTracesRequest, QueryDenomTracesResponse>({
+export const createGetDenomTraces = (clientResolver: RpcResolver) => buildQuery<QueryDenomTracesRequest, QueryDenomTracesResponse>({
   encode: QueryDenomTracesRequest.encode,
   decode: QueryDenomTracesResponse.decode,
   service: "ibc.applications.transfer.v1.Query",
   method: "DenomTraces",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomTraces = buildUseQuery<QueryDenomTracesRequest, QueryDenomTracesResponse>({
   builderQueryFn: createGetDenomTraces,
   queryKeyPrefix: "DenomTracesQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "ibc.applications.transfer.v1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/tx.rpc.func.ts
index b79a8a170..c64afe4ce 100644
--- a/__fixtures__/v-next/outputicjs/ibc/applications/transfer/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/query.rpc.func.ts
index 17e8a6f4a..2ecfe8561 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/query.rpc.func.ts
@@ -1,144 +1,144 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { QueryChannelRequest, QueryChannelResponse, QueryChannelsRequest, QueryChannelsResponse, QueryConnectionChannelsRequest, QueryConnectionChannelsResponse, QueryChannelClientStateRequest, QueryChannelClientStateResponse, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse, QueryPacketCommitmentRequest, QueryPacketCommitmentResponse, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse, QueryPacketReceiptRequest, QueryPacketReceiptResponse, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse } from "./query";
-export const createGetChannel = (getRpcInstance: RpcResolver) => buildQuery<QueryChannelRequest, QueryChannelResponse>({
+export const createGetChannel = (clientResolver: RpcResolver) => buildQuery<QueryChannelRequest, QueryChannelResponse>({
   encode: QueryChannelRequest.encode,
   decode: QueryChannelResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "Channel",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetChannel = buildUseQuery<QueryChannelRequest, QueryChannelResponse>({
   builderQueryFn: createGetChannel,
   queryKeyPrefix: "ChannelQuery"
 });
-export const createGetChannels = (getRpcInstance: RpcResolver) => buildQuery<QueryChannelsRequest, QueryChannelsResponse>({
+export const createGetChannels = (clientResolver: RpcResolver) => buildQuery<QueryChannelsRequest, QueryChannelsResponse>({
   encode: QueryChannelsRequest.encode,
   decode: QueryChannelsResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "Channels",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetChannels = buildUseQuery<QueryChannelsRequest, QueryChannelsResponse>({
   builderQueryFn: createGetChannels,
   queryKeyPrefix: "ChannelsQuery"
 });
-export const createGetConnectionChannels = (getRpcInstance: RpcResolver) => buildQuery<QueryConnectionChannelsRequest, QueryConnectionChannelsResponse>({
+export const createGetConnectionChannels = (clientResolver: RpcResolver) => buildQuery<QueryConnectionChannelsRequest, QueryConnectionChannelsResponse>({
   encode: QueryConnectionChannelsRequest.encode,
   decode: QueryConnectionChannelsResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "ConnectionChannels",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnectionChannels = buildUseQuery<QueryConnectionChannelsRequest, QueryConnectionChannelsResponse>({
   builderQueryFn: createGetConnectionChannels,
   queryKeyPrefix: "ConnectionChannelsQuery"
 });
-export const createGetChannelClientState = (getRpcInstance: RpcResolver) => buildQuery<QueryChannelClientStateRequest, QueryChannelClientStateResponse>({
+export const createGetChannelClientState = (clientResolver: RpcResolver) => buildQuery<QueryChannelClientStateRequest, QueryChannelClientStateResponse>({
   encode: QueryChannelClientStateRequest.encode,
   decode: QueryChannelClientStateResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "ChannelClientState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetChannelClientState = buildUseQuery<QueryChannelClientStateRequest, QueryChannelClientStateResponse>({
   builderQueryFn: createGetChannelClientState,
   queryKeyPrefix: "ChannelClientStateQuery"
 });
-export const createGetChannelConsensusState = (getRpcInstance: RpcResolver) => buildQuery<QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse>({
+export const createGetChannelConsensusState = (clientResolver: RpcResolver) => buildQuery<QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse>({
   encode: QueryChannelConsensusStateRequest.encode,
   decode: QueryChannelConsensusStateResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "ChannelConsensusState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetChannelConsensusState = buildUseQuery<QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse>({
   builderQueryFn: createGetChannelConsensusState,
   queryKeyPrefix: "ChannelConsensusStateQuery"
 });
-export const createGetPacketCommitment = (getRpcInstance: RpcResolver) => buildQuery<QueryPacketCommitmentRequest, QueryPacketCommitmentResponse>({
+export const createGetPacketCommitment = (clientResolver: RpcResolver) => buildQuery<QueryPacketCommitmentRequest, QueryPacketCommitmentResponse>({
   encode: QueryPacketCommitmentRequest.encode,
   decode: QueryPacketCommitmentResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "PacketCommitment",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPacketCommitment = buildUseQuery<QueryPacketCommitmentRequest, QueryPacketCommitmentResponse>({
   builderQueryFn: createGetPacketCommitment,
   queryKeyPrefix: "PacketCommitmentQuery"
 });
-export const createGetPacketCommitments = (getRpcInstance: RpcResolver) => buildQuery<QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse>({
+export const createGetPacketCommitments = (clientResolver: RpcResolver) => buildQuery<QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse>({
   encode: QueryPacketCommitmentsRequest.encode,
   decode: QueryPacketCommitmentsResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "PacketCommitments",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPacketCommitments = buildUseQuery<QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse>({
   builderQueryFn: createGetPacketCommitments,
   queryKeyPrefix: "PacketCommitmentsQuery"
 });
-export const createGetPacketReceipt = (getRpcInstance: RpcResolver) => buildQuery<QueryPacketReceiptRequest, QueryPacketReceiptResponse>({
+export const createGetPacketReceipt = (clientResolver: RpcResolver) => buildQuery<QueryPacketReceiptRequest, QueryPacketReceiptResponse>({
   encode: QueryPacketReceiptRequest.encode,
   decode: QueryPacketReceiptResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "PacketReceipt",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPacketReceipt = buildUseQuery<QueryPacketReceiptRequest, QueryPacketReceiptResponse>({
   builderQueryFn: createGetPacketReceipt,
   queryKeyPrefix: "PacketReceiptQuery"
 });
-export const createGetPacketAcknowledgement = (getRpcInstance: RpcResolver) => buildQuery<QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse>({
+export const createGetPacketAcknowledgement = (clientResolver: RpcResolver) => buildQuery<QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse>({
   encode: QueryPacketAcknowledgementRequest.encode,
   decode: QueryPacketAcknowledgementResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "PacketAcknowledgement",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPacketAcknowledgement = buildUseQuery<QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse>({
   builderQueryFn: createGetPacketAcknowledgement,
   queryKeyPrefix: "PacketAcknowledgementQuery"
 });
-export const createGetPacketAcknowledgements = (getRpcInstance: RpcResolver) => buildQuery<QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse>({
+export const createGetPacketAcknowledgements = (clientResolver: RpcResolver) => buildQuery<QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse>({
   encode: QueryPacketAcknowledgementsRequest.encode,
   decode: QueryPacketAcknowledgementsResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "PacketAcknowledgements",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPacketAcknowledgements = buildUseQuery<QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse>({
   builderQueryFn: createGetPacketAcknowledgements,
   queryKeyPrefix: "PacketAcknowledgementsQuery"
 });
-export const createGetUnreceivedPackets = (getRpcInstance: RpcResolver) => buildQuery<QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse>({
+export const createGetUnreceivedPackets = (clientResolver: RpcResolver) => buildQuery<QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse>({
   encode: QueryUnreceivedPacketsRequest.encode,
   decode: QueryUnreceivedPacketsResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "UnreceivedPackets",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUnreceivedPackets = buildUseQuery<QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse>({
   builderQueryFn: createGetUnreceivedPackets,
   queryKeyPrefix: "UnreceivedPacketsQuery"
 });
-export const createGetUnreceivedAcks = (getRpcInstance: RpcResolver) => buildQuery<QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse>({
+export const createGetUnreceivedAcks = (clientResolver: RpcResolver) => buildQuery<QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse>({
   encode: QueryUnreceivedAcksRequest.encode,
   decode: QueryUnreceivedAcksResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "UnreceivedAcks",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUnreceivedAcks = buildUseQuery<QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse>({
   builderQueryFn: createGetUnreceivedAcks,
   queryKeyPrefix: "UnreceivedAcksQuery"
 });
-export const createGetNextSequenceReceive = (getRpcInstance: RpcResolver) => buildQuery<QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse>({
+export const createGetNextSequenceReceive = (clientResolver: RpcResolver) => buildQuery<QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse>({
   encode: QueryNextSequenceReceiveRequest.encode,
   decode: QueryNextSequenceReceiveResponse.decode,
   service: "ibc.core.channel.v1.Query",
   method: "NextSequenceReceive",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetNextSequenceReceive = buildUseQuery<QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse>({
   builderQueryFn: createGetNextSequenceReceive,
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/tx.rpc.func.ts
index f21bd0342..8b6d47d61 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/channel/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/client/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/client/v1/query.rpc.func.ts
index a58991457..0eb49676c 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/client/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/ibc/core/client/v1/query.rpc.func.ts
@@ -1,89 +1,89 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { QueryClientStateRequest, QueryClientStateResponse, QueryClientStatesRequest, QueryClientStatesResponse, QueryConsensusStateRequest, QueryConsensusStateResponse, QueryConsensusStatesRequest, QueryConsensusStatesResponse, QueryClientStatusRequest, QueryClientStatusResponse, QueryClientParamsRequest, QueryClientParamsResponse, QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse } from "./query";
-export const createGetClientState = (getRpcInstance: RpcResolver) => buildQuery<QueryClientStateRequest, QueryClientStateResponse>({
+export const createGetClientState = (clientResolver: RpcResolver) => buildQuery<QueryClientStateRequest, QueryClientStateResponse>({
   encode: QueryClientStateRequest.encode,
   decode: QueryClientStateResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ClientState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClientState = buildUseQuery<QueryClientStateRequest, QueryClientStateResponse>({
   builderQueryFn: createGetClientState,
   queryKeyPrefix: "ClientStateQuery"
 });
-export const createGetClientStates = (getRpcInstance: RpcResolver) => buildQuery<QueryClientStatesRequest, QueryClientStatesResponse>({
+export const createGetClientStates = (clientResolver: RpcResolver) => buildQuery<QueryClientStatesRequest, QueryClientStatesResponse>({
   encode: QueryClientStatesRequest.encode,
   decode: QueryClientStatesResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ClientStates",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClientStates = buildUseQuery<QueryClientStatesRequest, QueryClientStatesResponse>({
   builderQueryFn: createGetClientStates,
   queryKeyPrefix: "ClientStatesQuery"
 });
-export const createGetConsensusState = (getRpcInstance: RpcResolver) => buildQuery<QueryConsensusStateRequest, QueryConsensusStateResponse>({
+export const createGetConsensusState = (clientResolver: RpcResolver) => buildQuery<QueryConsensusStateRequest, QueryConsensusStateResponse>({
   encode: QueryConsensusStateRequest.encode,
   decode: QueryConsensusStateResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ConsensusState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConsensusState = buildUseQuery<QueryConsensusStateRequest, QueryConsensusStateResponse>({
   builderQueryFn: createGetConsensusState,
   queryKeyPrefix: "ConsensusStateQuery"
 });
-export const createGetConsensusStates = (getRpcInstance: RpcResolver) => buildQuery<QueryConsensusStatesRequest, QueryConsensusStatesResponse>({
+export const createGetConsensusStates = (clientResolver: RpcResolver) => buildQuery<QueryConsensusStatesRequest, QueryConsensusStatesResponse>({
   encode: QueryConsensusStatesRequest.encode,
   decode: QueryConsensusStatesResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ConsensusStates",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConsensusStates = buildUseQuery<QueryConsensusStatesRequest, QueryConsensusStatesResponse>({
   builderQueryFn: createGetConsensusStates,
   queryKeyPrefix: "ConsensusStatesQuery"
 });
-export const createGetClientStatus = (getRpcInstance: RpcResolver) => buildQuery<QueryClientStatusRequest, QueryClientStatusResponse>({
+export const createGetClientStatus = (clientResolver: RpcResolver) => buildQuery<QueryClientStatusRequest, QueryClientStatusResponse>({
   encode: QueryClientStatusRequest.encode,
   decode: QueryClientStatusResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ClientStatus",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClientStatus = buildUseQuery<QueryClientStatusRequest, QueryClientStatusResponse>({
   builderQueryFn: createGetClientStatus,
   queryKeyPrefix: "ClientStatusQuery"
 });
-export const createGetClientParams = (getRpcInstance: RpcResolver) => buildQuery<QueryClientParamsRequest, QueryClientParamsResponse>({
+export const createGetClientParams = (clientResolver: RpcResolver) => buildQuery<QueryClientParamsRequest, QueryClientParamsResponse>({
   encode: QueryClientParamsRequest.encode,
   decode: QueryClientParamsResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "ClientParams",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClientParams = buildUseQuery<QueryClientParamsRequest, QueryClientParamsResponse>({
   builderQueryFn: createGetClientParams,
   queryKeyPrefix: "ClientParamsQuery"
 });
-export const createGetUpgradedClientState = (getRpcInstance: RpcResolver) => buildQuery<QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse>({
+export const createGetUpgradedClientState = (clientResolver: RpcResolver) => buildQuery<QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse>({
   encode: QueryUpgradedClientStateRequest.encode,
   decode: QueryUpgradedClientStateResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "UpgradedClientState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUpgradedClientState = buildUseQuery<QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse>({
   builderQueryFn: createGetUpgradedClientState,
   queryKeyPrefix: "UpgradedClientStateQuery"
 });
-export const createGetUpgradedConsensusState = (getRpcInstance: RpcResolver) => buildQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
+export const createGetUpgradedConsensusState = (clientResolver: RpcResolver) => buildQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
   encode: QueryUpgradedConsensusStateRequest.encode,
   decode: QueryUpgradedConsensusStateResponse.decode,
   service: "ibc.core.client.v1.Query",
   method: "UpgradedConsensusState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUpgradedConsensusState = buildUseQuery<QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse>({
   builderQueryFn: createGetUpgradedConsensusState,
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/client/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/client/v1/tx.rpc.func.ts
index 3ebc15c29..cca711914 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/client/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/query.rpc.func.ts
index fab80a121..ef1d04ffe 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/query.rpc.func.ts
@@ -1,56 +1,56 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse, QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse } from "./query";
-export const createGetConnection = (getRpcInstance: RpcResolver) => buildQuery<QueryConnectionRequest, QueryConnectionResponse>({
+export const createGetConnection = (clientResolver: RpcResolver) => buildQuery<QueryConnectionRequest, QueryConnectionResponse>({
   encode: QueryConnectionRequest.encode,
   decode: QueryConnectionResponse.decode,
   service: "ibc.core.connection.v1.Query",
   method: "Connection",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnection = buildUseQuery<QueryConnectionRequest, QueryConnectionResponse>({
   builderQueryFn: createGetConnection,
   queryKeyPrefix: "ConnectionQuery"
 });
-export const createGetConnections = (getRpcInstance: RpcResolver) => buildQuery<QueryConnectionsRequest, QueryConnectionsResponse>({
+export const createGetConnections = (clientResolver: RpcResolver) => buildQuery<QueryConnectionsRequest, QueryConnectionsResponse>({
   encode: QueryConnectionsRequest.encode,
   decode: QueryConnectionsResponse.decode,
   service: "ibc.core.connection.v1.Query",
   method: "Connections",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnections = buildUseQuery<QueryConnectionsRequest, QueryConnectionsResponse>({
   builderQueryFn: createGetConnections,
   queryKeyPrefix: "ConnectionsQuery"
 });
-export const createGetClientConnections = (getRpcInstance: RpcResolver) => buildQuery<QueryClientConnectionsRequest, QueryClientConnectionsResponse>({
+export const createGetClientConnections = (clientResolver: RpcResolver) => buildQuery<QueryClientConnectionsRequest, QueryClientConnectionsResponse>({
   encode: QueryClientConnectionsRequest.encode,
   decode: QueryClientConnectionsResponse.decode,
   service: "ibc.core.connection.v1.Query",
   method: "ClientConnections",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClientConnections = buildUseQuery<QueryClientConnectionsRequest, QueryClientConnectionsResponse>({
   builderQueryFn: createGetClientConnections,
   queryKeyPrefix: "ClientConnectionsQuery"
 });
-export const createGetConnectionClientState = (getRpcInstance: RpcResolver) => buildQuery<QueryConnectionClientStateRequest, QueryConnectionClientStateResponse>({
+export const createGetConnectionClientState = (clientResolver: RpcResolver) => buildQuery<QueryConnectionClientStateRequest, QueryConnectionClientStateResponse>({
   encode: QueryConnectionClientStateRequest.encode,
   decode: QueryConnectionClientStateResponse.decode,
   service: "ibc.core.connection.v1.Query",
   method: "ConnectionClientState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnectionClientState = buildUseQuery<QueryConnectionClientStateRequest, QueryConnectionClientStateResponse>({
   builderQueryFn: createGetConnectionClientState,
   queryKeyPrefix: "ConnectionClientStateQuery"
 });
-export const createGetConnectionConsensusState = (getRpcInstance: RpcResolver) => buildQuery<QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse>({
+export const createGetConnectionConsensusState = (clientResolver: RpcResolver) => buildQuery<QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse>({
   encode: QueryConnectionConsensusStateRequest.encode,
   decode: QueryConnectionConsensusStateResponse.decode,
   service: "ibc.core.connection.v1.Query",
   method: "ConnectionConsensusState",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnectionConsensusState = buildUseQuery<QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse>({
   builderQueryFn: createGetConnectionConsensusState,
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/tx.rpc.func.ts
index 750421514..fcd17dbb1 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/connection/v1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/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 } 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)
diff --git a/__fixtures__/v-next/outputicjs/ibc/core/port/v1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/ibc/core/port/v1/query.rpc.func.ts
index b0fa0bced..8c82a3fe1 100644
--- a/__fixtures__/v-next/outputicjs/ibc/core/port/v1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/ibc/core/port/v1/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../../helper-func-types";
 import { buildUseQuery } from "../../../../react-query";
 import { QueryAppVersionRequest, QueryAppVersionResponse } from "./query";
-export const createGetAppVersion = (getRpcInstance: RpcResolver) => buildQuery<QueryAppVersionRequest, QueryAppVersionResponse>({
+export const createGetAppVersion = (clientResolver: RpcResolver) => buildQuery<QueryAppVersionRequest, QueryAppVersionResponse>({
   encode: QueryAppVersionRequest.encode,
   decode: QueryAppVersionResponse.decode,
   service: "ibc.core.port.v1.Query",
   method: "AppVersion",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAppVersion = buildUseQuery<QueryAppVersionRequest, QueryAppVersionResponse>({
   builderQueryFn: createGetAppVersion,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/claim/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/claim/v1beta1/query.rpc.func.ts
index ca1263950..03d1dde6a 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/claim/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/claim/v1beta1/query.rpc.func.ts
@@ -1,56 +1,56 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryModuleAccountBalanceRequest, QueryModuleAccountBalanceResponse, QueryParamsRequest, QueryParamsResponse, QueryClaimRecordRequest, QueryClaimRecordResponse, QueryClaimableForActionRequest, QueryClaimableForActionResponse, QueryTotalClaimableRequest, QueryTotalClaimableResponse } from "./query";
-export const createGetModuleAccountBalance = (getRpcInstance: RpcResolver) => buildQuery<QueryModuleAccountBalanceRequest, QueryModuleAccountBalanceResponse>({
+export const createGetModuleAccountBalance = (clientResolver: RpcResolver) => buildQuery<QueryModuleAccountBalanceRequest, QueryModuleAccountBalanceResponse>({
   encode: QueryModuleAccountBalanceRequest.encode,
   decode: QueryModuleAccountBalanceResponse.decode,
   service: "osmosis.claim.v1beta1.Query",
   method: "ModuleAccountBalance",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleAccountBalance = buildUseQuery<QueryModuleAccountBalanceRequest, QueryModuleAccountBalanceResponse>({
   builderQueryFn: createGetModuleAccountBalance,
   queryKeyPrefix: "ModuleAccountBalanceQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.claim.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetClaimRecord = (getRpcInstance: RpcResolver) => buildQuery<QueryClaimRecordRequest, QueryClaimRecordResponse>({
+export const createGetClaimRecord = (clientResolver: RpcResolver) => buildQuery<QueryClaimRecordRequest, QueryClaimRecordResponse>({
   encode: QueryClaimRecordRequest.encode,
   decode: QueryClaimRecordResponse.decode,
   service: "osmosis.claim.v1beta1.Query",
   method: "ClaimRecord",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClaimRecord = buildUseQuery<QueryClaimRecordRequest, QueryClaimRecordResponse>({
   builderQueryFn: createGetClaimRecord,
   queryKeyPrefix: "ClaimRecordQuery"
 });
-export const createGetClaimableForAction = (getRpcInstance: RpcResolver) => buildQuery<QueryClaimableForActionRequest, QueryClaimableForActionResponse>({
+export const createGetClaimableForAction = (clientResolver: RpcResolver) => buildQuery<QueryClaimableForActionRequest, QueryClaimableForActionResponse>({
   encode: QueryClaimableForActionRequest.encode,
   decode: QueryClaimableForActionResponse.decode,
   service: "osmosis.claim.v1beta1.Query",
   method: "ClaimableForAction",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetClaimableForAction = buildUseQuery<QueryClaimableForActionRequest, QueryClaimableForActionResponse>({
   builderQueryFn: createGetClaimableForAction,
   queryKeyPrefix: "ClaimableForActionQuery"
 });
-export const createGetTotalClaimable = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalClaimableRequest, QueryTotalClaimableResponse>({
+export const createGetTotalClaimable = (clientResolver: RpcResolver) => buildQuery<QueryTotalClaimableRequest, QueryTotalClaimableResponse>({
   encode: QueryTotalClaimableRequest.encode,
   decode: QueryTotalClaimableResponse.decode,
   service: "osmosis.claim.v1beta1.Query",
   method: "TotalClaimable",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalClaimable = buildUseQuery<QueryTotalClaimableRequest, QueryTotalClaimableResponse>({
   builderQueryFn: createGetTotalClaimable,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/epochs/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/epochs/query.rpc.func.ts
index d34b5a2a7..ede9bdbb0 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/epochs/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/epochs/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../helper-func-types";
 import { buildUseQuery } from "../../react-query";
 import { QueryEpochsInfoRequest, QueryEpochsInfoResponse, QueryCurrentEpochRequest, QueryCurrentEpochResponse } from "./query";
-export const createGetEpochInfos = (getRpcInstance: RpcResolver) => buildQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
+export const createGetEpochInfos = (clientResolver: RpcResolver) => buildQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
   encode: QueryEpochsInfoRequest.encode,
   decode: QueryEpochsInfoResponse.decode,
   service: "osmosis.epochs.v1beta1.Query",
   method: "EpochInfos",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEpochInfos = buildUseQuery<QueryEpochsInfoRequest, QueryEpochsInfoResponse>({
   builderQueryFn: createGetEpochInfos,
   queryKeyPrefix: "EpochInfosQuery"
 });
-export const createGetCurrentEpoch = (getRpcInstance: RpcResolver) => buildQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
+export const createGetCurrentEpoch = (clientResolver: RpcResolver) => buildQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
   encode: QueryCurrentEpochRequest.encode,
   decode: QueryCurrentEpochResponse.decode,
   service: "osmosis.epochs.v1beta1.Query",
   method: "CurrentEpoch",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCurrentEpoch = buildUseQuery<QueryCurrentEpochRequest, QueryCurrentEpochResponse>({
   builderQueryFn: createGetCurrentEpoch,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/balancer/tx/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/balancer/tx/tx.rpc.func.ts
index 6b704e311..debe4fc35 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/balancer/tx/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/balancer/tx/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 { MsgCreateBalancerPool } from "./tx";
-export const createCreateBalancerPool = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateBalancerPool>({
-  getSigningClient: getSigningClient,
+export const createCreateBalancerPool = (clientResolver: SigningClientResolver) => buildTx<MsgCreateBalancerPool>({
+  clientResolver,
   typeUrl: MsgCreateBalancerPool.typeUrl,
   encoders: toEncoders(MsgCreateBalancerPool),
   converters: toConverters(MsgCreateBalancerPool)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/stableswap/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/stableswap/tx.rpc.func.ts
index 32688ca5c..60dd23607 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/stableswap/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/gamm/pool-models/stableswap/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 { MsgCreateStableswapPool, MsgStableSwapAdjustScalingFactors } from "./tx";
-export const createCreateStableswapPool = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateStableswapPool>({
-  getSigningClient: getSigningClient,
+export const createCreateStableswapPool = (clientResolver: SigningClientResolver) => buildTx<MsgCreateStableswapPool>({
+  clientResolver,
   typeUrl: MsgCreateStableswapPool.typeUrl,
   encoders: toEncoders(MsgCreateStableswapPool),
   converters: toConverters(MsgCreateStableswapPool)
@@ -11,8 +11,8 @@ export const createCreateStableswapPool = (getSigningClient: SigningClientResolv
 export const useCreateStableswapPool = buildUseMutation<MsgCreateStableswapPool, Error>({
   builderMutationFn: createCreateStableswapPool
 });
-export const createStableSwapAdjustScalingFactors = (getSigningClient: SigningClientResolver) => buildTx<MsgStableSwapAdjustScalingFactors>({
-  getSigningClient: getSigningClient,
+export const createStableSwapAdjustScalingFactors = (clientResolver: SigningClientResolver) => buildTx<MsgStableSwapAdjustScalingFactors>({
+  clientResolver,
   typeUrl: MsgStableSwapAdjustScalingFactors.typeUrl,
   encoders: toEncoders(MsgStableSwapAdjustScalingFactors),
   converters: toConverters(MsgStableSwapAdjustScalingFactors)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/query.rpc.func.ts
index 3a09ed900..6c06fda75 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/query.rpc.func.ts
@@ -1,166 +1,166 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryPoolsRequest, QueryPoolsResponse, QueryNumPoolsRequest, QueryNumPoolsResponse, QueryTotalLiquidityRequest, QueryTotalLiquidityResponse, QueryPoolsWithFilterRequest, QueryPoolsWithFilterResponse, QueryPoolRequest, QueryPoolResponse, QueryPoolTypeRequest, QueryPoolTypeResponse, QueryCalcJoinPoolNoSwapSharesRequest, QueryCalcJoinPoolNoSwapSharesResponse, QueryCalcJoinPoolSharesRequest, QueryCalcJoinPoolSharesResponse, QueryCalcExitPoolCoinsFromSharesRequest, QueryCalcExitPoolCoinsFromSharesResponse, QueryPoolParamsRequest, QueryPoolParamsResponse, QueryTotalPoolLiquidityRequest, QueryTotalPoolLiquidityResponse, QueryTotalSharesRequest, QueryTotalSharesResponse, QuerySpotPriceRequest, QuerySpotPriceResponse, QuerySwapExactAmountInRequest, QuerySwapExactAmountInResponse, QuerySwapExactAmountOutRequest, QuerySwapExactAmountOutResponse } from "./query";
-export const createGetPools = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolsRequest, QueryPoolsResponse>({
+export const createGetPools = (clientResolver: RpcResolver) => buildQuery<QueryPoolsRequest, QueryPoolsResponse>({
   encode: QueryPoolsRequest.encode,
   decode: QueryPoolsResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "Pools",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPools = buildUseQuery<QueryPoolsRequest, QueryPoolsResponse>({
   builderQueryFn: createGetPools,
   queryKeyPrefix: "PoolsQuery"
 });
-export const createGetNumPools = (getRpcInstance: RpcResolver) => buildQuery<QueryNumPoolsRequest, QueryNumPoolsResponse>({
+export const createGetNumPools = (clientResolver: RpcResolver) => buildQuery<QueryNumPoolsRequest, QueryNumPoolsResponse>({
   encode: QueryNumPoolsRequest.encode,
   decode: QueryNumPoolsResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "NumPools",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetNumPools = buildUseQuery<QueryNumPoolsRequest, QueryNumPoolsResponse>({
   builderQueryFn: createGetNumPools,
   queryKeyPrefix: "NumPoolsQuery"
 });
-export const createGetTotalLiquidity = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalLiquidityRequest, QueryTotalLiquidityResponse>({
+export const createGetTotalLiquidity = (clientResolver: RpcResolver) => buildQuery<QueryTotalLiquidityRequest, QueryTotalLiquidityResponse>({
   encode: QueryTotalLiquidityRequest.encode,
   decode: QueryTotalLiquidityResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "TotalLiquidity",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalLiquidity = buildUseQuery<QueryTotalLiquidityRequest, QueryTotalLiquidityResponse>({
   builderQueryFn: createGetTotalLiquidity,
   queryKeyPrefix: "TotalLiquidityQuery"
 });
-export const createGetPoolsWithFilter = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolsWithFilterRequest, QueryPoolsWithFilterResponse>({
+export const createGetPoolsWithFilter = (clientResolver: RpcResolver) => buildQuery<QueryPoolsWithFilterRequest, QueryPoolsWithFilterResponse>({
   encode: QueryPoolsWithFilterRequest.encode,
   decode: QueryPoolsWithFilterResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "PoolsWithFilter",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPoolsWithFilter = buildUseQuery<QueryPoolsWithFilterRequest, QueryPoolsWithFilterResponse>({
   builderQueryFn: createGetPoolsWithFilter,
   queryKeyPrefix: "PoolsWithFilterQuery"
 });
-export const createGetPool = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolRequest, QueryPoolResponse>({
+export const createGetPool = (clientResolver: RpcResolver) => buildQuery<QueryPoolRequest, QueryPoolResponse>({
   encode: QueryPoolRequest.encode,
   decode: QueryPoolResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "Pool",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPool = buildUseQuery<QueryPoolRequest, QueryPoolResponse>({
   builderQueryFn: createGetPool,
   queryKeyPrefix: "PoolQuery"
 });
-export const createGetPoolType = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolTypeRequest, QueryPoolTypeResponse>({
+export const createGetPoolType = (clientResolver: RpcResolver) => buildQuery<QueryPoolTypeRequest, QueryPoolTypeResponse>({
   encode: QueryPoolTypeRequest.encode,
   decode: QueryPoolTypeResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "PoolType",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPoolType = buildUseQuery<QueryPoolTypeRequest, QueryPoolTypeResponse>({
   builderQueryFn: createGetPoolType,
   queryKeyPrefix: "PoolTypeQuery"
 });
-export const createGetCalcJoinPoolNoSwapShares = (getRpcInstance: RpcResolver) => buildQuery<QueryCalcJoinPoolNoSwapSharesRequest, QueryCalcJoinPoolNoSwapSharesResponse>({
+export const createGetCalcJoinPoolNoSwapShares = (clientResolver: RpcResolver) => buildQuery<QueryCalcJoinPoolNoSwapSharesRequest, QueryCalcJoinPoolNoSwapSharesResponse>({
   encode: QueryCalcJoinPoolNoSwapSharesRequest.encode,
   decode: QueryCalcJoinPoolNoSwapSharesResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "CalcJoinPoolNoSwapShares",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCalcJoinPoolNoSwapShares = buildUseQuery<QueryCalcJoinPoolNoSwapSharesRequest, QueryCalcJoinPoolNoSwapSharesResponse>({
   builderQueryFn: createGetCalcJoinPoolNoSwapShares,
   queryKeyPrefix: "CalcJoinPoolNoSwapSharesQuery"
 });
-export const createGetCalcJoinPoolShares = (getRpcInstance: RpcResolver) => buildQuery<QueryCalcJoinPoolSharesRequest, QueryCalcJoinPoolSharesResponse>({
+export const createGetCalcJoinPoolShares = (clientResolver: RpcResolver) => buildQuery<QueryCalcJoinPoolSharesRequest, QueryCalcJoinPoolSharesResponse>({
   encode: QueryCalcJoinPoolSharesRequest.encode,
   decode: QueryCalcJoinPoolSharesResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "CalcJoinPoolShares",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCalcJoinPoolShares = buildUseQuery<QueryCalcJoinPoolSharesRequest, QueryCalcJoinPoolSharesResponse>({
   builderQueryFn: createGetCalcJoinPoolShares,
   queryKeyPrefix: "CalcJoinPoolSharesQuery"
 });
-export const createGetCalcExitPoolCoinsFromShares = (getRpcInstance: RpcResolver) => buildQuery<QueryCalcExitPoolCoinsFromSharesRequest, QueryCalcExitPoolCoinsFromSharesResponse>({
+export const createGetCalcExitPoolCoinsFromShares = (clientResolver: RpcResolver) => buildQuery<QueryCalcExitPoolCoinsFromSharesRequest, QueryCalcExitPoolCoinsFromSharesResponse>({
   encode: QueryCalcExitPoolCoinsFromSharesRequest.encode,
   decode: QueryCalcExitPoolCoinsFromSharesResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "CalcExitPoolCoinsFromShares",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCalcExitPoolCoinsFromShares = buildUseQuery<QueryCalcExitPoolCoinsFromSharesRequest, QueryCalcExitPoolCoinsFromSharesResponse>({
   builderQueryFn: createGetCalcExitPoolCoinsFromShares,
   queryKeyPrefix: "CalcExitPoolCoinsFromSharesQuery"
 });
-export const createGetPoolParams = (getRpcInstance: RpcResolver) => buildQuery<QueryPoolParamsRequest, QueryPoolParamsResponse>({
+export const createGetPoolParams = (clientResolver: RpcResolver) => buildQuery<QueryPoolParamsRequest, QueryPoolParamsResponse>({
   encode: QueryPoolParamsRequest.encode,
   decode: QueryPoolParamsResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "PoolParams",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetPoolParams = buildUseQuery<QueryPoolParamsRequest, QueryPoolParamsResponse>({
   builderQueryFn: createGetPoolParams,
   queryKeyPrefix: "PoolParamsQuery"
 });
-export const createGetTotalPoolLiquidity = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalPoolLiquidityRequest, QueryTotalPoolLiquidityResponse>({
+export const createGetTotalPoolLiquidity = (clientResolver: RpcResolver) => buildQuery<QueryTotalPoolLiquidityRequest, QueryTotalPoolLiquidityResponse>({
   encode: QueryTotalPoolLiquidityRequest.encode,
   decode: QueryTotalPoolLiquidityResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "TotalPoolLiquidity",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalPoolLiquidity = buildUseQuery<QueryTotalPoolLiquidityRequest, QueryTotalPoolLiquidityResponse>({
   builderQueryFn: createGetTotalPoolLiquidity,
   queryKeyPrefix: "TotalPoolLiquidityQuery"
 });
-export const createGetTotalShares = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalSharesRequest, QueryTotalSharesResponse>({
+export const createGetTotalShares = (clientResolver: RpcResolver) => buildQuery<QueryTotalSharesRequest, QueryTotalSharesResponse>({
   encode: QueryTotalSharesRequest.encode,
   decode: QueryTotalSharesResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "TotalShares",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalShares = buildUseQuery<QueryTotalSharesRequest, QueryTotalSharesResponse>({
   builderQueryFn: createGetTotalShares,
   queryKeyPrefix: "TotalSharesQuery"
 });
-export const createGetSpotPrice = (getRpcInstance: RpcResolver) => buildQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
+export const createGetSpotPrice = (clientResolver: RpcResolver) => buildQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
   encode: QuerySpotPriceRequest.encode,
   decode: QuerySpotPriceResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "SpotPrice",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSpotPrice = buildUseQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
   builderQueryFn: createGetSpotPrice,
   queryKeyPrefix: "SpotPriceQuery"
 });
-export const createGetEstimateSwapExactAmountIn = (getRpcInstance: RpcResolver) => buildQuery<QuerySwapExactAmountInRequest, QuerySwapExactAmountInResponse>({
+export const createGetEstimateSwapExactAmountIn = (clientResolver: RpcResolver) => buildQuery<QuerySwapExactAmountInRequest, QuerySwapExactAmountInResponse>({
   encode: QuerySwapExactAmountInRequest.encode,
   decode: QuerySwapExactAmountInResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "EstimateSwapExactAmountIn",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEstimateSwapExactAmountIn = buildUseQuery<QuerySwapExactAmountInRequest, QuerySwapExactAmountInResponse>({
   builderQueryFn: createGetEstimateSwapExactAmountIn,
   queryKeyPrefix: "EstimateSwapExactAmountInQuery"
 });
-export const createGetEstimateSwapExactAmountOut = (getRpcInstance: RpcResolver) => buildQuery<QuerySwapExactAmountOutRequest, QuerySwapExactAmountOutResponse>({
+export const createGetEstimateSwapExactAmountOut = (clientResolver: RpcResolver) => buildQuery<QuerySwapExactAmountOutRequest, QuerySwapExactAmountOutResponse>({
   encode: QuerySwapExactAmountOutRequest.encode,
   decode: QuerySwapExactAmountOutResponse.decode,
   service: "osmosis.gamm.v1beta1.Query",
   method: "EstimateSwapExactAmountOut",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEstimateSwapExactAmountOut = buildUseQuery<QuerySwapExactAmountOutRequest, QuerySwapExactAmountOutResponse>({
   builderQueryFn: createGetEstimateSwapExactAmountOut,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/tx.rpc.func.ts
index 5a46540c2..1e0e11c53 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/gamm/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/gamm/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 { MsgJoinPool, MsgExitPool, MsgSwapExactAmountIn, MsgSwapExactAmountOut, MsgJoinSwapExternAmountIn, MsgJoinSwapShareAmountOut, MsgExitSwapExternAmountOut, MsgExitSwapShareAmountIn } from "./tx";
-export const createJoinPool = (getSigningClient: SigningClientResolver) => buildTx<MsgJoinPool>({
-  getSigningClient: getSigningClient,
+export const createJoinPool = (clientResolver: SigningClientResolver) => buildTx<MsgJoinPool>({
+  clientResolver,
   typeUrl: MsgJoinPool.typeUrl,
   encoders: toEncoders(MsgJoinPool),
   converters: toConverters(MsgJoinPool)
@@ -11,8 +11,8 @@ export const createJoinPool = (getSigningClient: SigningClientResolver) => build
 export const useJoinPool = buildUseMutation<MsgJoinPool, Error>({
   builderMutationFn: createJoinPool
 });
-export const createExitPool = (getSigningClient: SigningClientResolver) => buildTx<MsgExitPool>({
-  getSigningClient: getSigningClient,
+export const createExitPool = (clientResolver: SigningClientResolver) => buildTx<MsgExitPool>({
+  clientResolver,
   typeUrl: MsgExitPool.typeUrl,
   encoders: toEncoders(MsgExitPool),
   converters: toConverters(MsgExitPool)
@@ -20,8 +20,8 @@ export const createExitPool = (getSigningClient: SigningClientResolver) => build
 export const useExitPool = buildUseMutation<MsgExitPool, Error>({
   builderMutationFn: createExitPool
 });
-export const createSwapExactAmountIn = (getSigningClient: SigningClientResolver) => buildTx<MsgSwapExactAmountIn>({
-  getSigningClient: getSigningClient,
+export const createSwapExactAmountIn = (clientResolver: SigningClientResolver) => buildTx<MsgSwapExactAmountIn>({
+  clientResolver,
   typeUrl: MsgSwapExactAmountIn.typeUrl,
   encoders: toEncoders(MsgSwapExactAmountIn),
   converters: toConverters(MsgSwapExactAmountIn)
@@ -29,8 +29,8 @@ export const createSwapExactAmountIn = (getSigningClient: SigningClientResolver)
 export const useSwapExactAmountIn = buildUseMutation<MsgSwapExactAmountIn, Error>({
   builderMutationFn: createSwapExactAmountIn
 });
-export const createSwapExactAmountOut = (getSigningClient: SigningClientResolver) => buildTx<MsgSwapExactAmountOut>({
-  getSigningClient: getSigningClient,
+export const createSwapExactAmountOut = (clientResolver: SigningClientResolver) => buildTx<MsgSwapExactAmountOut>({
+  clientResolver,
   typeUrl: MsgSwapExactAmountOut.typeUrl,
   encoders: toEncoders(MsgSwapExactAmountOut),
   converters: toConverters(MsgSwapExactAmountOut)
@@ -38,8 +38,8 @@ export const createSwapExactAmountOut = (getSigningClient: SigningClientResolver
 export const useSwapExactAmountOut = buildUseMutation<MsgSwapExactAmountOut, Error>({
   builderMutationFn: createSwapExactAmountOut
 });
-export const createJoinSwapExternAmountIn = (getSigningClient: SigningClientResolver) => buildTx<MsgJoinSwapExternAmountIn>({
-  getSigningClient: getSigningClient,
+export const createJoinSwapExternAmountIn = (clientResolver: SigningClientResolver) => buildTx<MsgJoinSwapExternAmountIn>({
+  clientResolver,
   typeUrl: MsgJoinSwapExternAmountIn.typeUrl,
   encoders: toEncoders(MsgJoinSwapExternAmountIn),
   converters: toConverters(MsgJoinSwapExternAmountIn)
@@ -47,8 +47,8 @@ export const createJoinSwapExternAmountIn = (getSigningClient: SigningClientReso
 export const useJoinSwapExternAmountIn = buildUseMutation<MsgJoinSwapExternAmountIn, Error>({
   builderMutationFn: createJoinSwapExternAmountIn
 });
-export const createJoinSwapShareAmountOut = (getSigningClient: SigningClientResolver) => buildTx<MsgJoinSwapShareAmountOut>({
-  getSigningClient: getSigningClient,
+export const createJoinSwapShareAmountOut = (clientResolver: SigningClientResolver) => buildTx<MsgJoinSwapShareAmountOut>({
+  clientResolver,
   typeUrl: MsgJoinSwapShareAmountOut.typeUrl,
   encoders: toEncoders(MsgJoinSwapShareAmountOut),
   converters: toConverters(MsgJoinSwapShareAmountOut)
@@ -56,8 +56,8 @@ export const createJoinSwapShareAmountOut = (getSigningClient: SigningClientReso
 export const useJoinSwapShareAmountOut = buildUseMutation<MsgJoinSwapShareAmountOut, Error>({
   builderMutationFn: createJoinSwapShareAmountOut
 });
-export const createExitSwapExternAmountOut = (getSigningClient: SigningClientResolver) => buildTx<MsgExitSwapExternAmountOut>({
-  getSigningClient: getSigningClient,
+export const createExitSwapExternAmountOut = (clientResolver: SigningClientResolver) => buildTx<MsgExitSwapExternAmountOut>({
+  clientResolver,
   typeUrl: MsgExitSwapExternAmountOut.typeUrl,
   encoders: toEncoders(MsgExitSwapExternAmountOut),
   converters: toConverters(MsgExitSwapExternAmountOut)
@@ -65,8 +65,8 @@ export const createExitSwapExternAmountOut = (getSigningClient: SigningClientRes
 export const useExitSwapExternAmountOut = buildUseMutation<MsgExitSwapExternAmountOut, Error>({
   builderMutationFn: createExitSwapExternAmountOut
 });
-export const createExitSwapShareAmountIn = (getSigningClient: SigningClientResolver) => buildTx<MsgExitSwapShareAmountIn>({
-  getSigningClient: getSigningClient,
+export const createExitSwapShareAmountIn = (clientResolver: SigningClientResolver) => buildTx<MsgExitSwapShareAmountIn>({
+  clientResolver,
   typeUrl: MsgExitSwapShareAmountIn.typeUrl,
   encoders: toEncoders(MsgExitSwapShareAmountIn),
   converters: toConverters(MsgExitSwapShareAmountIn)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/gamm/v2/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/gamm/v2/query.rpc.func.ts
index 396d416da..506e13b49 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/gamm/v2/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/gamm/v2/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QuerySpotPriceRequest, QuerySpotPriceResponse } from "./query";
-export const createGetSpotPrice = (getRpcInstance: RpcResolver) => buildQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
+export const createGetSpotPrice = (clientResolver: RpcResolver) => buildQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
   encode: QuerySpotPriceRequest.encode,
   decode: QuerySpotPriceResponse.decode,
   service: "osmosis.gamm.v2.Query",
   method: "SpotPrice",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSpotPrice = buildUseQuery<QuerySpotPriceRequest, QuerySpotPriceResponse>({
   builderQueryFn: createGetSpotPrice,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/ibc-rate-limit/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/ibc-rate-limit/v1beta1/query.rpc.func.ts
index 90677d59e..e5b1af301 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/ibc-rate-limit/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/ibc-rate-limit/v1beta1/query.rpc.func.ts
@@ -1,12 +1,12 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.ibcratelimit.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/incentives/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/incentives/query.rpc.func.ts
index 6b2e2b717..5d95f970a 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/incentives/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/incentives/query.rpc.func.ts
@@ -1,100 +1,100 @@
 import { RpcResolver, buildQuery } from "../../helper-func-types";
 import { buildUseQuery } from "../../react-query";
 import { ModuleToDistributeCoinsRequest, ModuleToDistributeCoinsResponse, GaugeByIDRequest, GaugeByIDResponse, GaugesRequest, GaugesResponse, ActiveGaugesRequest, ActiveGaugesResponse, ActiveGaugesPerDenomRequest, ActiveGaugesPerDenomResponse, UpcomingGaugesRequest, UpcomingGaugesResponse, UpcomingGaugesPerDenomRequest, UpcomingGaugesPerDenomResponse, RewardsEstRequest, RewardsEstResponse, QueryLockableDurationsRequest, QueryLockableDurationsResponse } from "./query";
-export const createGetModuleToDistributeCoins = (getRpcInstance: RpcResolver) => buildQuery<ModuleToDistributeCoinsRequest, ModuleToDistributeCoinsResponse>({
+export const createGetModuleToDistributeCoins = (clientResolver: RpcResolver) => buildQuery<ModuleToDistributeCoinsRequest, ModuleToDistributeCoinsResponse>({
   encode: ModuleToDistributeCoinsRequest.encode,
   decode: ModuleToDistributeCoinsResponse.decode,
   service: "osmosis.incentives.Query",
   method: "ModuleToDistributeCoins",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleToDistributeCoins = buildUseQuery<ModuleToDistributeCoinsRequest, ModuleToDistributeCoinsResponse>({
   builderQueryFn: createGetModuleToDistributeCoins,
   queryKeyPrefix: "ModuleToDistributeCoinsQuery"
 });
-export const createGetGaugeByID = (getRpcInstance: RpcResolver) => buildQuery<GaugeByIDRequest, GaugeByIDResponse>({
+export const createGetGaugeByID = (clientResolver: RpcResolver) => buildQuery<GaugeByIDRequest, GaugeByIDResponse>({
   encode: GaugeByIDRequest.encode,
   decode: GaugeByIDResponse.decode,
   service: "osmosis.incentives.Query",
   method: "GaugeByID",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGaugeByID = buildUseQuery<GaugeByIDRequest, GaugeByIDResponse>({
   builderQueryFn: createGetGaugeByID,
   queryKeyPrefix: "GaugeByIDQuery"
 });
-export const createGetGauges = (getRpcInstance: RpcResolver) => buildQuery<GaugesRequest, GaugesResponse>({
+export const createGetGauges = (clientResolver: RpcResolver) => buildQuery<GaugesRequest, GaugesResponse>({
   encode: GaugesRequest.encode,
   decode: GaugesResponse.decode,
   service: "osmosis.incentives.Query",
   method: "Gauges",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGauges = buildUseQuery<GaugesRequest, GaugesResponse>({
   builderQueryFn: createGetGauges,
   queryKeyPrefix: "GaugesQuery"
 });
-export const createGetActiveGauges = (getRpcInstance: RpcResolver) => buildQuery<ActiveGaugesRequest, ActiveGaugesResponse>({
+export const createGetActiveGauges = (clientResolver: RpcResolver) => buildQuery<ActiveGaugesRequest, ActiveGaugesResponse>({
   encode: ActiveGaugesRequest.encode,
   decode: ActiveGaugesResponse.decode,
   service: "osmosis.incentives.Query",
   method: "ActiveGauges",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetActiveGauges = buildUseQuery<ActiveGaugesRequest, ActiveGaugesResponse>({
   builderQueryFn: createGetActiveGauges,
   queryKeyPrefix: "ActiveGaugesQuery"
 });
-export const createGetActiveGaugesPerDenom = (getRpcInstance: RpcResolver) => buildQuery<ActiveGaugesPerDenomRequest, ActiveGaugesPerDenomResponse>({
+export const createGetActiveGaugesPerDenom = (clientResolver: RpcResolver) => buildQuery<ActiveGaugesPerDenomRequest, ActiveGaugesPerDenomResponse>({
   encode: ActiveGaugesPerDenomRequest.encode,
   decode: ActiveGaugesPerDenomResponse.decode,
   service: "osmosis.incentives.Query",
   method: "ActiveGaugesPerDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetActiveGaugesPerDenom = buildUseQuery<ActiveGaugesPerDenomRequest, ActiveGaugesPerDenomResponse>({
   builderQueryFn: createGetActiveGaugesPerDenom,
   queryKeyPrefix: "ActiveGaugesPerDenomQuery"
 });
-export const createGetUpcomingGauges = (getRpcInstance: RpcResolver) => buildQuery<UpcomingGaugesRequest, UpcomingGaugesResponse>({
+export const createGetUpcomingGauges = (clientResolver: RpcResolver) => buildQuery<UpcomingGaugesRequest, UpcomingGaugesResponse>({
   encode: UpcomingGaugesRequest.encode,
   decode: UpcomingGaugesResponse.decode,
   service: "osmosis.incentives.Query",
   method: "UpcomingGauges",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUpcomingGauges = buildUseQuery<UpcomingGaugesRequest, UpcomingGaugesResponse>({
   builderQueryFn: createGetUpcomingGauges,
   queryKeyPrefix: "UpcomingGaugesQuery"
 });
-export const createGetUpcomingGaugesPerDenom = (getRpcInstance: RpcResolver) => buildQuery<UpcomingGaugesPerDenomRequest, UpcomingGaugesPerDenomResponse>({
+export const createGetUpcomingGaugesPerDenom = (clientResolver: RpcResolver) => buildQuery<UpcomingGaugesPerDenomRequest, UpcomingGaugesPerDenomResponse>({
   encode: UpcomingGaugesPerDenomRequest.encode,
   decode: UpcomingGaugesPerDenomResponse.decode,
   service: "osmosis.incentives.Query",
   method: "UpcomingGaugesPerDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUpcomingGaugesPerDenom = buildUseQuery<UpcomingGaugesPerDenomRequest, UpcomingGaugesPerDenomResponse>({
   builderQueryFn: createGetUpcomingGaugesPerDenom,
   queryKeyPrefix: "UpcomingGaugesPerDenomQuery"
 });
-export const createGetRewardsEst = (getRpcInstance: RpcResolver) => buildQuery<RewardsEstRequest, RewardsEstResponse>({
+export const createGetRewardsEst = (clientResolver: RpcResolver) => buildQuery<RewardsEstRequest, RewardsEstResponse>({
   encode: RewardsEstRequest.encode,
   decode: RewardsEstResponse.decode,
   service: "osmosis.incentives.Query",
   method: "RewardsEst",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetRewardsEst = buildUseQuery<RewardsEstRequest, RewardsEstResponse>({
   builderQueryFn: createGetRewardsEst,
   queryKeyPrefix: "RewardsEstQuery"
 });
-export const createGetLockableDurations = (getRpcInstance: RpcResolver) => buildQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
+export const createGetLockableDurations = (clientResolver: RpcResolver) => buildQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
   encode: QueryLockableDurationsRequest.encode,
   decode: QueryLockableDurationsResponse.decode,
   service: "osmosis.incentives.Query",
   method: "LockableDurations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLockableDurations = buildUseQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
   builderQueryFn: createGetLockableDurations,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/incentives/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/incentives/tx.rpc.func.ts
index 31a386751..4b2104e89 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/incentives/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/incentives/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 { MsgCreateGauge, MsgAddToGauge } from "./tx";
-export const createCreateGauge = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateGauge>({
-  getSigningClient: getSigningClient,
+export const createCreateGauge = (clientResolver: SigningClientResolver) => buildTx<MsgCreateGauge>({
+  clientResolver,
   typeUrl: MsgCreateGauge.typeUrl,
   encoders: toEncoders(MsgCreateGauge),
   converters: toConverters(MsgCreateGauge)
@@ -11,8 +11,8 @@ export const createCreateGauge = (getSigningClient: SigningClientResolver) => bu
 export const useCreateGauge = buildUseMutation<MsgCreateGauge, Error>({
   builderMutationFn: createCreateGauge
 });
-export const createAddToGauge = (getSigningClient: SigningClientResolver) => buildTx<MsgAddToGauge>({
-  getSigningClient: getSigningClient,
+export const createAddToGauge = (clientResolver: SigningClientResolver) => buildTx<MsgAddToGauge>({
+  clientResolver,
   typeUrl: MsgAddToGauge.typeUrl,
   encoders: toEncoders(MsgAddToGauge),
   converters: toConverters(MsgAddToGauge)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/lockup/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/lockup/query.rpc.func.ts
index 246a365e3..35052e4fb 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/lockup/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/lockup/query.rpc.func.ts
@@ -1,188 +1,188 @@
 import { RpcResolver, buildQuery } from "../../helper-func-types";
 import { buildUseQuery } from "../../react-query";
 import { ModuleBalanceRequest, ModuleBalanceResponse, ModuleLockedAmountRequest, ModuleLockedAmountResponse, AccountUnlockableCoinsRequest, AccountUnlockableCoinsResponse, AccountUnlockingCoinsRequest, AccountUnlockingCoinsResponse, AccountLockedCoinsRequest, AccountLockedCoinsResponse, AccountLockedPastTimeRequest, AccountLockedPastTimeResponse, AccountLockedPastTimeNotUnlockingOnlyRequest, AccountLockedPastTimeNotUnlockingOnlyResponse, AccountUnlockedBeforeTimeRequest, AccountUnlockedBeforeTimeResponse, AccountLockedPastTimeDenomRequest, AccountLockedPastTimeDenomResponse, LockedDenomRequest, LockedDenomResponse, LockedRequest, LockedResponse, SyntheticLockupsByLockupIDRequest, SyntheticLockupsByLockupIDResponse, AccountLockedLongerDurationRequest, AccountLockedLongerDurationResponse, AccountLockedDurationRequest, AccountLockedDurationResponse, AccountLockedLongerDurationNotUnlockingOnlyRequest, AccountLockedLongerDurationNotUnlockingOnlyResponse, AccountLockedLongerDurationDenomRequest, AccountLockedLongerDurationDenomResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
-export const createGetModuleBalance = (getRpcInstance: RpcResolver) => buildQuery<ModuleBalanceRequest, ModuleBalanceResponse>({
+export const createGetModuleBalance = (clientResolver: RpcResolver) => buildQuery<ModuleBalanceRequest, ModuleBalanceResponse>({
   encode: ModuleBalanceRequest.encode,
   decode: ModuleBalanceResponse.decode,
   service: "osmosis.lockup.Query",
   method: "ModuleBalance",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleBalance = buildUseQuery<ModuleBalanceRequest, ModuleBalanceResponse>({
   builderQueryFn: createGetModuleBalance,
   queryKeyPrefix: "ModuleBalanceQuery"
 });
-export const createGetModuleLockedAmount = (getRpcInstance: RpcResolver) => buildQuery<ModuleLockedAmountRequest, ModuleLockedAmountResponse>({
+export const createGetModuleLockedAmount = (clientResolver: RpcResolver) => buildQuery<ModuleLockedAmountRequest, ModuleLockedAmountResponse>({
   encode: ModuleLockedAmountRequest.encode,
   decode: ModuleLockedAmountResponse.decode,
   service: "osmosis.lockup.Query",
   method: "ModuleLockedAmount",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetModuleLockedAmount = buildUseQuery<ModuleLockedAmountRequest, ModuleLockedAmountResponse>({
   builderQueryFn: createGetModuleLockedAmount,
   queryKeyPrefix: "ModuleLockedAmountQuery"
 });
-export const createGetAccountUnlockableCoins = (getRpcInstance: RpcResolver) => buildQuery<AccountUnlockableCoinsRequest, AccountUnlockableCoinsResponse>({
+export const createGetAccountUnlockableCoins = (clientResolver: RpcResolver) => buildQuery<AccountUnlockableCoinsRequest, AccountUnlockableCoinsResponse>({
   encode: AccountUnlockableCoinsRequest.encode,
   decode: AccountUnlockableCoinsResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountUnlockableCoins",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountUnlockableCoins = buildUseQuery<AccountUnlockableCoinsRequest, AccountUnlockableCoinsResponse>({
   builderQueryFn: createGetAccountUnlockableCoins,
   queryKeyPrefix: "AccountUnlockableCoinsQuery"
 });
-export const createGetAccountUnlockingCoins = (getRpcInstance: RpcResolver) => buildQuery<AccountUnlockingCoinsRequest, AccountUnlockingCoinsResponse>({
+export const createGetAccountUnlockingCoins = (clientResolver: RpcResolver) => buildQuery<AccountUnlockingCoinsRequest, AccountUnlockingCoinsResponse>({
   encode: AccountUnlockingCoinsRequest.encode,
   decode: AccountUnlockingCoinsResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountUnlockingCoins",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountUnlockingCoins = buildUseQuery<AccountUnlockingCoinsRequest, AccountUnlockingCoinsResponse>({
   builderQueryFn: createGetAccountUnlockingCoins,
   queryKeyPrefix: "AccountUnlockingCoinsQuery"
 });
-export const createGetAccountLockedCoins = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedCoinsRequest, AccountLockedCoinsResponse>({
+export const createGetAccountLockedCoins = (clientResolver: RpcResolver) => buildQuery<AccountLockedCoinsRequest, AccountLockedCoinsResponse>({
   encode: AccountLockedCoinsRequest.encode,
   decode: AccountLockedCoinsResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedCoins",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedCoins = buildUseQuery<AccountLockedCoinsRequest, AccountLockedCoinsResponse>({
   builderQueryFn: createGetAccountLockedCoins,
   queryKeyPrefix: "AccountLockedCoinsQuery"
 });
-export const createGetAccountLockedPastTime = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedPastTimeRequest, AccountLockedPastTimeResponse>({
+export const createGetAccountLockedPastTime = (clientResolver: RpcResolver) => buildQuery<AccountLockedPastTimeRequest, AccountLockedPastTimeResponse>({
   encode: AccountLockedPastTimeRequest.encode,
   decode: AccountLockedPastTimeResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedPastTime",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedPastTime = buildUseQuery<AccountLockedPastTimeRequest, AccountLockedPastTimeResponse>({
   builderQueryFn: createGetAccountLockedPastTime,
   queryKeyPrefix: "AccountLockedPastTimeQuery"
 });
-export const createGetAccountLockedPastTimeNotUnlockingOnly = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedPastTimeNotUnlockingOnlyRequest, AccountLockedPastTimeNotUnlockingOnlyResponse>({
+export const createGetAccountLockedPastTimeNotUnlockingOnly = (clientResolver: RpcResolver) => buildQuery<AccountLockedPastTimeNotUnlockingOnlyRequest, AccountLockedPastTimeNotUnlockingOnlyResponse>({
   encode: AccountLockedPastTimeNotUnlockingOnlyRequest.encode,
   decode: AccountLockedPastTimeNotUnlockingOnlyResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedPastTimeNotUnlockingOnly",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedPastTimeNotUnlockingOnly = buildUseQuery<AccountLockedPastTimeNotUnlockingOnlyRequest, AccountLockedPastTimeNotUnlockingOnlyResponse>({
   builderQueryFn: createGetAccountLockedPastTimeNotUnlockingOnly,
   queryKeyPrefix: "AccountLockedPastTimeNotUnlockingOnlyQuery"
 });
-export const createGetAccountUnlockedBeforeTime = (getRpcInstance: RpcResolver) => buildQuery<AccountUnlockedBeforeTimeRequest, AccountUnlockedBeforeTimeResponse>({
+export const createGetAccountUnlockedBeforeTime = (clientResolver: RpcResolver) => buildQuery<AccountUnlockedBeforeTimeRequest, AccountUnlockedBeforeTimeResponse>({
   encode: AccountUnlockedBeforeTimeRequest.encode,
   decode: AccountUnlockedBeforeTimeResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountUnlockedBeforeTime",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountUnlockedBeforeTime = buildUseQuery<AccountUnlockedBeforeTimeRequest, AccountUnlockedBeforeTimeResponse>({
   builderQueryFn: createGetAccountUnlockedBeforeTime,
   queryKeyPrefix: "AccountUnlockedBeforeTimeQuery"
 });
-export const createGetAccountLockedPastTimeDenom = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedPastTimeDenomRequest, AccountLockedPastTimeDenomResponse>({
+export const createGetAccountLockedPastTimeDenom = (clientResolver: RpcResolver) => buildQuery<AccountLockedPastTimeDenomRequest, AccountLockedPastTimeDenomResponse>({
   encode: AccountLockedPastTimeDenomRequest.encode,
   decode: AccountLockedPastTimeDenomResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedPastTimeDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedPastTimeDenom = buildUseQuery<AccountLockedPastTimeDenomRequest, AccountLockedPastTimeDenomResponse>({
   builderQueryFn: createGetAccountLockedPastTimeDenom,
   queryKeyPrefix: "AccountLockedPastTimeDenomQuery"
 });
-export const createGetLockedDenom = (getRpcInstance: RpcResolver) => buildQuery<LockedDenomRequest, LockedDenomResponse>({
+export const createGetLockedDenom = (clientResolver: RpcResolver) => buildQuery<LockedDenomRequest, LockedDenomResponse>({
   encode: LockedDenomRequest.encode,
   decode: LockedDenomResponse.decode,
   service: "osmosis.lockup.Query",
   method: "LockedDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLockedDenom = buildUseQuery<LockedDenomRequest, LockedDenomResponse>({
   builderQueryFn: createGetLockedDenom,
   queryKeyPrefix: "LockedDenomQuery"
 });
-export const createGetLockedByID = (getRpcInstance: RpcResolver) => buildQuery<LockedRequest, LockedResponse>({
+export const createGetLockedByID = (clientResolver: RpcResolver) => buildQuery<LockedRequest, LockedResponse>({
   encode: LockedRequest.encode,
   decode: LockedResponse.decode,
   service: "osmosis.lockup.Query",
   method: "LockedByID",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLockedByID = buildUseQuery<LockedRequest, LockedResponse>({
   builderQueryFn: createGetLockedByID,
   queryKeyPrefix: "LockedByIDQuery"
 });
-export const createGetSyntheticLockupsByLockupID = (getRpcInstance: RpcResolver) => buildQuery<SyntheticLockupsByLockupIDRequest, SyntheticLockupsByLockupIDResponse>({
+export const createGetSyntheticLockupsByLockupID = (clientResolver: RpcResolver) => buildQuery<SyntheticLockupsByLockupIDRequest, SyntheticLockupsByLockupIDResponse>({
   encode: SyntheticLockupsByLockupIDRequest.encode,
   decode: SyntheticLockupsByLockupIDResponse.decode,
   service: "osmosis.lockup.Query",
   method: "SyntheticLockupsByLockupID",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSyntheticLockupsByLockupID = buildUseQuery<SyntheticLockupsByLockupIDRequest, SyntheticLockupsByLockupIDResponse>({
   builderQueryFn: createGetSyntheticLockupsByLockupID,
   queryKeyPrefix: "SyntheticLockupsByLockupIDQuery"
 });
-export const createGetAccountLockedLongerDuration = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedLongerDurationRequest, AccountLockedLongerDurationResponse>({
+export const createGetAccountLockedLongerDuration = (clientResolver: RpcResolver) => buildQuery<AccountLockedLongerDurationRequest, AccountLockedLongerDurationResponse>({
   encode: AccountLockedLongerDurationRequest.encode,
   decode: AccountLockedLongerDurationResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedLongerDuration",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedLongerDuration = buildUseQuery<AccountLockedLongerDurationRequest, AccountLockedLongerDurationResponse>({
   builderQueryFn: createGetAccountLockedLongerDuration,
   queryKeyPrefix: "AccountLockedLongerDurationQuery"
 });
-export const createGetAccountLockedDuration = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedDurationRequest, AccountLockedDurationResponse>({
+export const createGetAccountLockedDuration = (clientResolver: RpcResolver) => buildQuery<AccountLockedDurationRequest, AccountLockedDurationResponse>({
   encode: AccountLockedDurationRequest.encode,
   decode: AccountLockedDurationResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedDuration",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedDuration = buildUseQuery<AccountLockedDurationRequest, AccountLockedDurationResponse>({
   builderQueryFn: createGetAccountLockedDuration,
   queryKeyPrefix: "AccountLockedDurationQuery"
 });
-export const createGetAccountLockedLongerDurationNotUnlockingOnly = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedLongerDurationNotUnlockingOnlyRequest, AccountLockedLongerDurationNotUnlockingOnlyResponse>({
+export const createGetAccountLockedLongerDurationNotUnlockingOnly = (clientResolver: RpcResolver) => buildQuery<AccountLockedLongerDurationNotUnlockingOnlyRequest, AccountLockedLongerDurationNotUnlockingOnlyResponse>({
   encode: AccountLockedLongerDurationNotUnlockingOnlyRequest.encode,
   decode: AccountLockedLongerDurationNotUnlockingOnlyResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedLongerDurationNotUnlockingOnly",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedLongerDurationNotUnlockingOnly = buildUseQuery<AccountLockedLongerDurationNotUnlockingOnlyRequest, AccountLockedLongerDurationNotUnlockingOnlyResponse>({
   builderQueryFn: createGetAccountLockedLongerDurationNotUnlockingOnly,
   queryKeyPrefix: "AccountLockedLongerDurationNotUnlockingOnlyQuery"
 });
-export const createGetAccountLockedLongerDurationDenom = (getRpcInstance: RpcResolver) => buildQuery<AccountLockedLongerDurationDenomRequest, AccountLockedLongerDurationDenomResponse>({
+export const createGetAccountLockedLongerDurationDenom = (clientResolver: RpcResolver) => buildQuery<AccountLockedLongerDurationDenomRequest, AccountLockedLongerDurationDenomResponse>({
   encode: AccountLockedLongerDurationDenomRequest.encode,
   decode: AccountLockedLongerDurationDenomResponse.decode,
   service: "osmosis.lockup.Query",
   method: "AccountLockedLongerDurationDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAccountLockedLongerDurationDenom = buildUseQuery<AccountLockedLongerDurationDenomRequest, AccountLockedLongerDurationDenomResponse>({
   builderQueryFn: createGetAccountLockedLongerDurationDenom,
   queryKeyPrefix: "AccountLockedLongerDurationDenomQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.lockup.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/lockup/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/lockup/tx.rpc.func.ts
index 86b5769c4..3cb2959ab 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/lockup/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/lockup/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 { MsgLockTokens, MsgBeginUnlockingAll, MsgBeginUnlocking, MsgExtendLockup, MsgForceUnlock } from "./tx";
-export const createLockTokens = (getSigningClient: SigningClientResolver) => buildTx<MsgLockTokens>({
-  getSigningClient: getSigningClient,
+export const createLockTokens = (clientResolver: SigningClientResolver) => buildTx<MsgLockTokens>({
+  clientResolver,
   typeUrl: MsgLockTokens.typeUrl,
   encoders: toEncoders(MsgLockTokens),
   converters: toConverters(MsgLockTokens)
@@ -11,8 +11,8 @@ export const createLockTokens = (getSigningClient: SigningClientResolver) => bui
 export const useLockTokens = buildUseMutation<MsgLockTokens, Error>({
   builderMutationFn: createLockTokens
 });
-export const createBeginUnlockingAll = (getSigningClient: SigningClientResolver) => buildTx<MsgBeginUnlockingAll>({
-  getSigningClient: getSigningClient,
+export const createBeginUnlockingAll = (clientResolver: SigningClientResolver) => buildTx<MsgBeginUnlockingAll>({
+  clientResolver,
   typeUrl: MsgBeginUnlockingAll.typeUrl,
   encoders: toEncoders(MsgBeginUnlockingAll),
   converters: toConverters(MsgBeginUnlockingAll)
@@ -20,8 +20,8 @@ export const createBeginUnlockingAll = (getSigningClient: SigningClientResolver)
 export const useBeginUnlockingAll = buildUseMutation<MsgBeginUnlockingAll, Error>({
   builderMutationFn: createBeginUnlockingAll
 });
-export const createBeginUnlocking = (getSigningClient: SigningClientResolver) => buildTx<MsgBeginUnlocking>({
-  getSigningClient: getSigningClient,
+export const createBeginUnlocking = (clientResolver: SigningClientResolver) => buildTx<MsgBeginUnlocking>({
+  clientResolver,
   typeUrl: MsgBeginUnlocking.typeUrl,
   encoders: toEncoders(MsgBeginUnlocking),
   converters: toConverters(MsgBeginUnlocking)
@@ -29,8 +29,8 @@ export const createBeginUnlocking = (getSigningClient: SigningClientResolver) =>
 export const useBeginUnlocking = buildUseMutation<MsgBeginUnlocking, Error>({
   builderMutationFn: createBeginUnlocking
 });
-export const createExtendLockup = (getSigningClient: SigningClientResolver) => buildTx<MsgExtendLockup>({
-  getSigningClient: getSigningClient,
+export const createExtendLockup = (clientResolver: SigningClientResolver) => buildTx<MsgExtendLockup>({
+  clientResolver,
   typeUrl: MsgExtendLockup.typeUrl,
   encoders: toEncoders(MsgExtendLockup),
   converters: toConverters(MsgExtendLockup)
@@ -38,8 +38,8 @@ export const createExtendLockup = (getSigningClient: SigningClientResolver) => b
 export const useExtendLockup = buildUseMutation<MsgExtendLockup, Error>({
   builderMutationFn: createExtendLockup
 });
-export const createForceUnlock = (getSigningClient: SigningClientResolver) => buildTx<MsgForceUnlock>({
-  getSigningClient: getSigningClient,
+export const createForceUnlock = (clientResolver: SigningClientResolver) => buildTx<MsgForceUnlock>({
+  clientResolver,
   typeUrl: MsgForceUnlock.typeUrl,
   encoders: toEncoders(MsgForceUnlock),
   converters: toConverters(MsgForceUnlock)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/mint/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/mint/v1beta1/query.rpc.func.ts
index cdd710661..d47d47567 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/mint/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/mint/v1beta1/query.rpc.func.ts
@@ -1,23 +1,23 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QueryEpochProvisionsRequest, QueryEpochProvisionsResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.mint.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetEpochProvisions = (getRpcInstance: RpcResolver) => buildQuery<QueryEpochProvisionsRequest, QueryEpochProvisionsResponse>({
+export const createGetEpochProvisions = (clientResolver: RpcResolver) => buildQuery<QueryEpochProvisionsRequest, QueryEpochProvisionsResponse>({
   encode: QueryEpochProvisionsRequest.encode,
   decode: QueryEpochProvisionsResponse.decode,
   service: "osmosis.mint.v1beta1.Query",
   method: "EpochProvisions",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEpochProvisions = buildUseQuery<QueryEpochProvisionsRequest, QueryEpochProvisionsResponse>({
   builderQueryFn: createGetEpochProvisions,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/pool-incentives/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/pool-incentives/v1beta1/query.rpc.func.ts
index 6df48340d..e60aa51e5 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/pool-incentives/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/pool-incentives/v1beta1/query.rpc.func.ts
@@ -1,67 +1,67 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryGaugeIdsRequest, QueryGaugeIdsResponse, QueryDistrInfoRequest, QueryDistrInfoResponse, QueryParamsRequest, QueryParamsResponse, QueryLockableDurationsRequest, QueryLockableDurationsResponse, QueryIncentivizedPoolsRequest, QueryIncentivizedPoolsResponse, QueryExternalIncentiveGaugesRequest, QueryExternalIncentiveGaugesResponse } from "./query";
-export const createGetGaugeIds = (getRpcInstance: RpcResolver) => buildQuery<QueryGaugeIdsRequest, QueryGaugeIdsResponse>({
+export const createGetGaugeIds = (clientResolver: RpcResolver) => buildQuery<QueryGaugeIdsRequest, QueryGaugeIdsResponse>({
   encode: QueryGaugeIdsRequest.encode,
   decode: QueryGaugeIdsResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "GaugeIds",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetGaugeIds = buildUseQuery<QueryGaugeIdsRequest, QueryGaugeIdsResponse>({
   builderQueryFn: createGetGaugeIds,
   queryKeyPrefix: "GaugeIdsQuery"
 });
-export const createGetDistrInfo = (getRpcInstance: RpcResolver) => buildQuery<QueryDistrInfoRequest, QueryDistrInfoResponse>({
+export const createGetDistrInfo = (clientResolver: RpcResolver) => buildQuery<QueryDistrInfoRequest, QueryDistrInfoResponse>({
   encode: QueryDistrInfoRequest.encode,
   decode: QueryDistrInfoResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "DistrInfo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDistrInfo = buildUseQuery<QueryDistrInfoRequest, QueryDistrInfoResponse>({
   builderQueryFn: createGetDistrInfo,
   queryKeyPrefix: "DistrInfoQuery"
 });
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetLockableDurations = (getRpcInstance: RpcResolver) => buildQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
+export const createGetLockableDurations = (clientResolver: RpcResolver) => buildQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
   encode: QueryLockableDurationsRequest.encode,
   decode: QueryLockableDurationsResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "LockableDurations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLockableDurations = buildUseQuery<QueryLockableDurationsRequest, QueryLockableDurationsResponse>({
   builderQueryFn: createGetLockableDurations,
   queryKeyPrefix: "LockableDurationsQuery"
 });
-export const createGetIncentivizedPools = (getRpcInstance: RpcResolver) => buildQuery<QueryIncentivizedPoolsRequest, QueryIncentivizedPoolsResponse>({
+export const createGetIncentivizedPools = (clientResolver: RpcResolver) => buildQuery<QueryIncentivizedPoolsRequest, QueryIncentivizedPoolsResponse>({
   encode: QueryIncentivizedPoolsRequest.encode,
   decode: QueryIncentivizedPoolsResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "IncentivizedPools",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetIncentivizedPools = buildUseQuery<QueryIncentivizedPoolsRequest, QueryIncentivizedPoolsResponse>({
   builderQueryFn: createGetIncentivizedPools,
   queryKeyPrefix: "IncentivizedPoolsQuery"
 });
-export const createGetExternalIncentiveGauges = (getRpcInstance: RpcResolver) => buildQuery<QueryExternalIncentiveGaugesRequest, QueryExternalIncentiveGaugesResponse>({
+export const createGetExternalIncentiveGauges = (clientResolver: RpcResolver) => buildQuery<QueryExternalIncentiveGaugesRequest, QueryExternalIncentiveGaugesResponse>({
   encode: QueryExternalIncentiveGaugesRequest.encode,
   decode: QueryExternalIncentiveGaugesResponse.decode,
   service: "osmosis.poolincentives.v1beta1.Query",
   method: "ExternalIncentiveGauges",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetExternalIncentiveGauges = buildUseQuery<QueryExternalIncentiveGaugesRequest, QueryExternalIncentiveGaugesResponse>({
   builderQueryFn: createGetExternalIncentiveGauges,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/superfluid/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/superfluid/query.rpc.func.ts
index ed3e0825c..47517101d 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/superfluid/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/superfluid/query.rpc.func.ts
@@ -1,166 +1,166 @@
 import { RpcResolver, buildQuery } from "../../helper-func-types";
 import { buildUseQuery } from "../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, AssetTypeRequest, AssetTypeResponse, AllAssetsRequest, AllAssetsResponse, AssetMultiplierRequest, AssetMultiplierResponse, AllIntermediaryAccountsRequest, AllIntermediaryAccountsResponse, ConnectedIntermediaryAccountRequest, ConnectedIntermediaryAccountResponse, QueryTotalDelegationByValidatorForDenomRequest, QueryTotalDelegationByValidatorForDenomResponse, TotalSuperfluidDelegationsRequest, TotalSuperfluidDelegationsResponse, SuperfluidDelegationAmountRequest, SuperfluidDelegationAmountResponse, SuperfluidDelegationsByDelegatorRequest, SuperfluidDelegationsByDelegatorResponse, SuperfluidUndelegationsByDelegatorRequest, SuperfluidUndelegationsByDelegatorResponse, SuperfluidDelegationsByValidatorDenomRequest, SuperfluidDelegationsByValidatorDenomResponse, EstimateSuperfluidDelegatedAmountByValidatorDenomRequest, EstimateSuperfluidDelegatedAmountByValidatorDenomResponse, QueryTotalDelegationByDelegatorRequest, QueryTotalDelegationByDelegatorResponse, QueryUnpoolWhitelistRequest, QueryUnpoolWhitelistResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetAssetType = (getRpcInstance: RpcResolver) => buildQuery<AssetTypeRequest, AssetTypeResponse>({
+export const createGetAssetType = (clientResolver: RpcResolver) => buildQuery<AssetTypeRequest, AssetTypeResponse>({
   encode: AssetTypeRequest.encode,
   decode: AssetTypeResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "AssetType",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAssetType = buildUseQuery<AssetTypeRequest, AssetTypeResponse>({
   builderQueryFn: createGetAssetType,
   queryKeyPrefix: "AssetTypeQuery"
 });
-export const createGetAllAssets = (getRpcInstance: RpcResolver) => buildQuery<AllAssetsRequest, AllAssetsResponse>({
+export const createGetAllAssets = (clientResolver: RpcResolver) => buildQuery<AllAssetsRequest, AllAssetsResponse>({
   encode: AllAssetsRequest.encode,
   decode: AllAssetsResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "AllAssets",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllAssets = buildUseQuery<AllAssetsRequest, AllAssetsResponse>({
   builderQueryFn: createGetAllAssets,
   queryKeyPrefix: "AllAssetsQuery"
 });
-export const createGetAssetMultiplier = (getRpcInstance: RpcResolver) => buildQuery<AssetMultiplierRequest, AssetMultiplierResponse>({
+export const createGetAssetMultiplier = (clientResolver: RpcResolver) => buildQuery<AssetMultiplierRequest, AssetMultiplierResponse>({
   encode: AssetMultiplierRequest.encode,
   decode: AssetMultiplierResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "AssetMultiplier",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAssetMultiplier = buildUseQuery<AssetMultiplierRequest, AssetMultiplierResponse>({
   builderQueryFn: createGetAssetMultiplier,
   queryKeyPrefix: "AssetMultiplierQuery"
 });
-export const createGetAllIntermediaryAccounts = (getRpcInstance: RpcResolver) => buildQuery<AllIntermediaryAccountsRequest, AllIntermediaryAccountsResponse>({
+export const createGetAllIntermediaryAccounts = (clientResolver: RpcResolver) => buildQuery<AllIntermediaryAccountsRequest, AllIntermediaryAccountsResponse>({
   encode: AllIntermediaryAccountsRequest.encode,
   decode: AllIntermediaryAccountsResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "AllIntermediaryAccounts",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetAllIntermediaryAccounts = buildUseQuery<AllIntermediaryAccountsRequest, AllIntermediaryAccountsResponse>({
   builderQueryFn: createGetAllIntermediaryAccounts,
   queryKeyPrefix: "AllIntermediaryAccountsQuery"
 });
-export const createGetConnectedIntermediaryAccount = (getRpcInstance: RpcResolver) => buildQuery<ConnectedIntermediaryAccountRequest, ConnectedIntermediaryAccountResponse>({
+export const createGetConnectedIntermediaryAccount = (clientResolver: RpcResolver) => buildQuery<ConnectedIntermediaryAccountRequest, ConnectedIntermediaryAccountResponse>({
   encode: ConnectedIntermediaryAccountRequest.encode,
   decode: ConnectedIntermediaryAccountResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "ConnectedIntermediaryAccount",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetConnectedIntermediaryAccount = buildUseQuery<ConnectedIntermediaryAccountRequest, ConnectedIntermediaryAccountResponse>({
   builderQueryFn: createGetConnectedIntermediaryAccount,
   queryKeyPrefix: "ConnectedIntermediaryAccountQuery"
 });
-export const createGetTotalDelegationByValidatorForDenom = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalDelegationByValidatorForDenomRequest, QueryTotalDelegationByValidatorForDenomResponse>({
+export const createGetTotalDelegationByValidatorForDenom = (clientResolver: RpcResolver) => buildQuery<QueryTotalDelegationByValidatorForDenomRequest, QueryTotalDelegationByValidatorForDenomResponse>({
   encode: QueryTotalDelegationByValidatorForDenomRequest.encode,
   decode: QueryTotalDelegationByValidatorForDenomResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "TotalDelegationByValidatorForDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalDelegationByValidatorForDenom = buildUseQuery<QueryTotalDelegationByValidatorForDenomRequest, QueryTotalDelegationByValidatorForDenomResponse>({
   builderQueryFn: createGetTotalDelegationByValidatorForDenom,
   queryKeyPrefix: "TotalDelegationByValidatorForDenomQuery"
 });
-export const createGetTotalSuperfluidDelegations = (getRpcInstance: RpcResolver) => buildQuery<TotalSuperfluidDelegationsRequest, TotalSuperfluidDelegationsResponse>({
+export const createGetTotalSuperfluidDelegations = (clientResolver: RpcResolver) => buildQuery<TotalSuperfluidDelegationsRequest, TotalSuperfluidDelegationsResponse>({
   encode: TotalSuperfluidDelegationsRequest.encode,
   decode: TotalSuperfluidDelegationsResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "TotalSuperfluidDelegations",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalSuperfluidDelegations = buildUseQuery<TotalSuperfluidDelegationsRequest, TotalSuperfluidDelegationsResponse>({
   builderQueryFn: createGetTotalSuperfluidDelegations,
   queryKeyPrefix: "TotalSuperfluidDelegationsQuery"
 });
-export const createGetSuperfluidDelegationAmount = (getRpcInstance: RpcResolver) => buildQuery<SuperfluidDelegationAmountRequest, SuperfluidDelegationAmountResponse>({
+export const createGetSuperfluidDelegationAmount = (clientResolver: RpcResolver) => buildQuery<SuperfluidDelegationAmountRequest, SuperfluidDelegationAmountResponse>({
   encode: SuperfluidDelegationAmountRequest.encode,
   decode: SuperfluidDelegationAmountResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "SuperfluidDelegationAmount",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSuperfluidDelegationAmount = buildUseQuery<SuperfluidDelegationAmountRequest, SuperfluidDelegationAmountResponse>({
   builderQueryFn: createGetSuperfluidDelegationAmount,
   queryKeyPrefix: "SuperfluidDelegationAmountQuery"
 });
-export const createGetSuperfluidDelegationsByDelegator = (getRpcInstance: RpcResolver) => buildQuery<SuperfluidDelegationsByDelegatorRequest, SuperfluidDelegationsByDelegatorResponse>({
+export const createGetSuperfluidDelegationsByDelegator = (clientResolver: RpcResolver) => buildQuery<SuperfluidDelegationsByDelegatorRequest, SuperfluidDelegationsByDelegatorResponse>({
   encode: SuperfluidDelegationsByDelegatorRequest.encode,
   decode: SuperfluidDelegationsByDelegatorResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "SuperfluidDelegationsByDelegator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSuperfluidDelegationsByDelegator = buildUseQuery<SuperfluidDelegationsByDelegatorRequest, SuperfluidDelegationsByDelegatorResponse>({
   builderQueryFn: createGetSuperfluidDelegationsByDelegator,
   queryKeyPrefix: "SuperfluidDelegationsByDelegatorQuery"
 });
-export const createGetSuperfluidUndelegationsByDelegator = (getRpcInstance: RpcResolver) => buildQuery<SuperfluidUndelegationsByDelegatorRequest, SuperfluidUndelegationsByDelegatorResponse>({
+export const createGetSuperfluidUndelegationsByDelegator = (clientResolver: RpcResolver) => buildQuery<SuperfluidUndelegationsByDelegatorRequest, SuperfluidUndelegationsByDelegatorResponse>({
   encode: SuperfluidUndelegationsByDelegatorRequest.encode,
   decode: SuperfluidUndelegationsByDelegatorResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "SuperfluidUndelegationsByDelegator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSuperfluidUndelegationsByDelegator = buildUseQuery<SuperfluidUndelegationsByDelegatorRequest, SuperfluidUndelegationsByDelegatorResponse>({
   builderQueryFn: createGetSuperfluidUndelegationsByDelegator,
   queryKeyPrefix: "SuperfluidUndelegationsByDelegatorQuery"
 });
-export const createGetSuperfluidDelegationsByValidatorDenom = (getRpcInstance: RpcResolver) => buildQuery<SuperfluidDelegationsByValidatorDenomRequest, SuperfluidDelegationsByValidatorDenomResponse>({
+export const createGetSuperfluidDelegationsByValidatorDenom = (clientResolver: RpcResolver) => buildQuery<SuperfluidDelegationsByValidatorDenomRequest, SuperfluidDelegationsByValidatorDenomResponse>({
   encode: SuperfluidDelegationsByValidatorDenomRequest.encode,
   decode: SuperfluidDelegationsByValidatorDenomResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "SuperfluidDelegationsByValidatorDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSuperfluidDelegationsByValidatorDenom = buildUseQuery<SuperfluidDelegationsByValidatorDenomRequest, SuperfluidDelegationsByValidatorDenomResponse>({
   builderQueryFn: createGetSuperfluidDelegationsByValidatorDenom,
   queryKeyPrefix: "SuperfluidDelegationsByValidatorDenomQuery"
 });
-export const createGetEstimateSuperfluidDelegatedAmountByValidatorDenom = (getRpcInstance: RpcResolver) => buildQuery<EstimateSuperfluidDelegatedAmountByValidatorDenomRequest, EstimateSuperfluidDelegatedAmountByValidatorDenomResponse>({
+export const createGetEstimateSuperfluidDelegatedAmountByValidatorDenom = (clientResolver: RpcResolver) => buildQuery<EstimateSuperfluidDelegatedAmountByValidatorDenomRequest, EstimateSuperfluidDelegatedAmountByValidatorDenomResponse>({
   encode: EstimateSuperfluidDelegatedAmountByValidatorDenomRequest.encode,
   decode: EstimateSuperfluidDelegatedAmountByValidatorDenomResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "EstimateSuperfluidDelegatedAmountByValidatorDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEstimateSuperfluidDelegatedAmountByValidatorDenom = buildUseQuery<EstimateSuperfluidDelegatedAmountByValidatorDenomRequest, EstimateSuperfluidDelegatedAmountByValidatorDenomResponse>({
   builderQueryFn: createGetEstimateSuperfluidDelegatedAmountByValidatorDenom,
   queryKeyPrefix: "EstimateSuperfluidDelegatedAmountByValidatorDenomQuery"
 });
-export const createGetTotalDelegationByDelegator = (getRpcInstance: RpcResolver) => buildQuery<QueryTotalDelegationByDelegatorRequest, QueryTotalDelegationByDelegatorResponse>({
+export const createGetTotalDelegationByDelegator = (clientResolver: RpcResolver) => buildQuery<QueryTotalDelegationByDelegatorRequest, QueryTotalDelegationByDelegatorResponse>({
   encode: QueryTotalDelegationByDelegatorRequest.encode,
   decode: QueryTotalDelegationByDelegatorResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "TotalDelegationByDelegator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetTotalDelegationByDelegator = buildUseQuery<QueryTotalDelegationByDelegatorRequest, QueryTotalDelegationByDelegatorResponse>({
   builderQueryFn: createGetTotalDelegationByDelegator,
   queryKeyPrefix: "TotalDelegationByDelegatorQuery"
 });
-export const createGetUnpoolWhitelist = (getRpcInstance: RpcResolver) => buildQuery<QueryUnpoolWhitelistRequest, QueryUnpoolWhitelistResponse>({
+export const createGetUnpoolWhitelist = (clientResolver: RpcResolver) => buildQuery<QueryUnpoolWhitelistRequest, QueryUnpoolWhitelistResponse>({
   encode: QueryUnpoolWhitelistRequest.encode,
   decode: QueryUnpoolWhitelistResponse.decode,
   service: "osmosis.superfluid.Query",
   method: "UnpoolWhitelist",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetUnpoolWhitelist = buildUseQuery<QueryUnpoolWhitelistRequest, QueryUnpoolWhitelistResponse>({
   builderQueryFn: createGetUnpoolWhitelist,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/superfluid/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/superfluid/tx.rpc.func.ts
index 1da7dea72..289f7daa9 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/superfluid/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/superfluid/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 { MsgSuperfluidDelegate, MsgSuperfluidUndelegate, MsgSuperfluidUnbondLock, MsgLockAndSuperfluidDelegate, MsgUnPoolWhitelistedPool } from "./tx";
-export const createSuperfluidDelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgSuperfluidDelegate>({
-  getSigningClient: getSigningClient,
+export const createSuperfluidDelegate = (clientResolver: SigningClientResolver) => buildTx<MsgSuperfluidDelegate>({
+  clientResolver,
   typeUrl: MsgSuperfluidDelegate.typeUrl,
   encoders: toEncoders(MsgSuperfluidDelegate),
   converters: toConverters(MsgSuperfluidDelegate)
@@ -11,8 +11,8 @@ export const createSuperfluidDelegate = (getSigningClient: SigningClientResolver
 export const useSuperfluidDelegate = buildUseMutation<MsgSuperfluidDelegate, Error>({
   builderMutationFn: createSuperfluidDelegate
 });
-export const createSuperfluidUndelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgSuperfluidUndelegate>({
-  getSigningClient: getSigningClient,
+export const createSuperfluidUndelegate = (clientResolver: SigningClientResolver) => buildTx<MsgSuperfluidUndelegate>({
+  clientResolver,
   typeUrl: MsgSuperfluidUndelegate.typeUrl,
   encoders: toEncoders(MsgSuperfluidUndelegate),
   converters: toConverters(MsgSuperfluidUndelegate)
@@ -20,8 +20,8 @@ export const createSuperfluidUndelegate = (getSigningClient: SigningClientResolv
 export const useSuperfluidUndelegate = buildUseMutation<MsgSuperfluidUndelegate, Error>({
   builderMutationFn: createSuperfluidUndelegate
 });
-export const createSuperfluidUnbondLock = (getSigningClient: SigningClientResolver) => buildTx<MsgSuperfluidUnbondLock>({
-  getSigningClient: getSigningClient,
+export const createSuperfluidUnbondLock = (clientResolver: SigningClientResolver) => buildTx<MsgSuperfluidUnbondLock>({
+  clientResolver,
   typeUrl: MsgSuperfluidUnbondLock.typeUrl,
   encoders: toEncoders(MsgSuperfluidUnbondLock),
   converters: toConverters(MsgSuperfluidUnbondLock)
@@ -29,8 +29,8 @@ export const createSuperfluidUnbondLock = (getSigningClient: SigningClientResolv
 export const useSuperfluidUnbondLock = buildUseMutation<MsgSuperfluidUnbondLock, Error>({
   builderMutationFn: createSuperfluidUnbondLock
 });
-export const createLockAndSuperfluidDelegate = (getSigningClient: SigningClientResolver) => buildTx<MsgLockAndSuperfluidDelegate>({
-  getSigningClient: getSigningClient,
+export const createLockAndSuperfluidDelegate = (clientResolver: SigningClientResolver) => buildTx<MsgLockAndSuperfluidDelegate>({
+  clientResolver,
   typeUrl: MsgLockAndSuperfluidDelegate.typeUrl,
   encoders: toEncoders(MsgLockAndSuperfluidDelegate),
   converters: toConverters(MsgLockAndSuperfluidDelegate)
@@ -38,8 +38,8 @@ export const createLockAndSuperfluidDelegate = (getSigningClient: SigningClientR
 export const useLockAndSuperfluidDelegate = buildUseMutation<MsgLockAndSuperfluidDelegate, Error>({
   builderMutationFn: createLockAndSuperfluidDelegate
 });
-export const createUnPoolWhitelistedPool = (getSigningClient: SigningClientResolver) => buildTx<MsgUnPoolWhitelistedPool>({
-  getSigningClient: getSigningClient,
+export const createUnPoolWhitelistedPool = (clientResolver: SigningClientResolver) => buildTx<MsgUnPoolWhitelistedPool>({
+  clientResolver,
   typeUrl: MsgUnPoolWhitelistedPool.typeUrl,
   encoders: toEncoders(MsgUnPoolWhitelistedPool),
   converters: toConverters(MsgUnPoolWhitelistedPool)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/query.rpc.func.ts
index 1f406e038..757575984 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryParamsRequest, QueryParamsResponse, QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse, QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
   encode: QueryParamsRequest.encode,
   decode: QueryParamsResponse.decode,
   service: "osmosis.tokenfactory.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<QueryParamsRequest, QueryParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetDenomAuthorityMetadata = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse>({
+export const createGetDenomAuthorityMetadata = (clientResolver: RpcResolver) => buildQuery<QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse>({
   encode: QueryDenomAuthorityMetadataRequest.encode,
   decode: QueryDenomAuthorityMetadataResponse.decode,
   service: "osmosis.tokenfactory.v1beta1.Query",
   method: "DenomAuthorityMetadata",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomAuthorityMetadata = buildUseQuery<QueryDenomAuthorityMetadataRequest, QueryDenomAuthorityMetadataResponse>({
   builderQueryFn: createGetDenomAuthorityMetadata,
   queryKeyPrefix: "DenomAuthorityMetadataQuery"
 });
-export const createGetDenomsFromCreator = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse>({
+export const createGetDenomsFromCreator = (clientResolver: RpcResolver) => buildQuery<QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse>({
   encode: QueryDenomsFromCreatorRequest.encode,
   decode: QueryDenomsFromCreatorResponse.decode,
   service: "osmosis.tokenfactory.v1beta1.Query",
   method: "DenomsFromCreator",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomsFromCreator = buildUseQuery<QueryDenomsFromCreatorRequest, QueryDenomsFromCreatorResponse>({
   builderQueryFn: createGetDenomsFromCreator,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/tx.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/tx.rpc.func.ts
index 55031a210..a609eb7fc 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/v1beta1/tx.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/tokenfactory/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 { MsgCreateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata } from "./tx";
-export const createCreateDenom = (getSigningClient: SigningClientResolver) => buildTx<MsgCreateDenom>({
-  getSigningClient: getSigningClient,
+export const createCreateDenom = (clientResolver: SigningClientResolver) => buildTx<MsgCreateDenom>({
+  clientResolver,
   typeUrl: MsgCreateDenom.typeUrl,
   encoders: toEncoders(MsgCreateDenom),
   converters: toConverters(MsgCreateDenom)
@@ -11,8 +11,8 @@ export const createCreateDenom = (getSigningClient: SigningClientResolver) => bu
 export const useCreateDenom = buildUseMutation<MsgCreateDenom, Error>({
   builderMutationFn: createCreateDenom
 });
-export const createMint = (getSigningClient: SigningClientResolver) => buildTx<MsgMint>({
-  getSigningClient: getSigningClient,
+export const createMint = (clientResolver: SigningClientResolver) => buildTx<MsgMint>({
+  clientResolver,
   typeUrl: MsgMint.typeUrl,
   encoders: toEncoders(MsgMint),
   converters: toConverters(MsgMint)
@@ -20,8 +20,8 @@ export const createMint = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useMint = buildUseMutation<MsgMint, Error>({
   builderMutationFn: createMint
 });
-export const createBurn = (getSigningClient: SigningClientResolver) => buildTx<MsgBurn>({
-  getSigningClient: getSigningClient,
+export const createBurn = (clientResolver: SigningClientResolver) => buildTx<MsgBurn>({
+  clientResolver,
   typeUrl: MsgBurn.typeUrl,
   encoders: toEncoders(MsgBurn),
   converters: toConverters(MsgBurn)
@@ -29,8 +29,8 @@ export const createBurn = (getSigningClient: SigningClientResolver) => buildTx<M
 export const useBurn = buildUseMutation<MsgBurn, Error>({
   builderMutationFn: createBurn
 });
-export const createChangeAdmin = (getSigningClient: SigningClientResolver) => buildTx<MsgChangeAdmin>({
-  getSigningClient: getSigningClient,
+export const createChangeAdmin = (clientResolver: SigningClientResolver) => buildTx<MsgChangeAdmin>({
+  clientResolver,
   typeUrl: MsgChangeAdmin.typeUrl,
   encoders: toEncoders(MsgChangeAdmin),
   converters: toConverters(MsgChangeAdmin)
@@ -38,8 +38,8 @@ export const createChangeAdmin = (getSigningClient: SigningClientResolver) => bu
 export const useChangeAdmin = buildUseMutation<MsgChangeAdmin, Error>({
   builderMutationFn: createChangeAdmin
 });
-export const createSetDenomMetadata = (getSigningClient: SigningClientResolver) => buildTx<MsgSetDenomMetadata>({
-  getSigningClient: getSigningClient,
+export const createSetDenomMetadata = (clientResolver: SigningClientResolver) => buildTx<MsgSetDenomMetadata>({
+  clientResolver,
   typeUrl: MsgSetDenomMetadata.typeUrl,
   encoders: toEncoders(MsgSetDenomMetadata),
   converters: toConverters(MsgSetDenomMetadata)
diff --git a/__fixtures__/v-next/outputicjs/osmosis/twap/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/twap/v1beta1/query.rpc.func.ts
index 13322f6c3..3765d81fb 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/twap/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/twap/v1beta1/query.rpc.func.ts
@@ -1,34 +1,34 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { ParamsRequest, ParamsResponse, ArithmeticTwapRequest, ArithmeticTwapResponse, ArithmeticTwapToNowRequest, ArithmeticTwapToNowResponse } from "./query";
-export const createGetParams = (getRpcInstance: RpcResolver) => buildQuery<ParamsRequest, ParamsResponse>({
+export const createGetParams = (clientResolver: RpcResolver) => buildQuery<ParamsRequest, ParamsResponse>({
   encode: ParamsRequest.encode,
   decode: ParamsResponse.decode,
   service: "osmosis.twap.v1beta1.Query",
   method: "Params",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetParams = buildUseQuery<ParamsRequest, ParamsResponse>({
   builderQueryFn: createGetParams,
   queryKeyPrefix: "ParamsQuery"
 });
-export const createGetArithmeticTwap = (getRpcInstance: RpcResolver) => buildQuery<ArithmeticTwapRequest, ArithmeticTwapResponse>({
+export const createGetArithmeticTwap = (clientResolver: RpcResolver) => buildQuery<ArithmeticTwapRequest, ArithmeticTwapResponse>({
   encode: ArithmeticTwapRequest.encode,
   decode: ArithmeticTwapResponse.decode,
   service: "osmosis.twap.v1beta1.Query",
   method: "ArithmeticTwap",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetArithmeticTwap = buildUseQuery<ArithmeticTwapRequest, ArithmeticTwapResponse>({
   builderQueryFn: createGetArithmeticTwap,
   queryKeyPrefix: "ArithmeticTwapQuery"
 });
-export const createGetArithmeticTwapToNow = (getRpcInstance: RpcResolver) => buildQuery<ArithmeticTwapToNowRequest, ArithmeticTwapToNowResponse>({
+export const createGetArithmeticTwapToNow = (clientResolver: RpcResolver) => buildQuery<ArithmeticTwapToNowRequest, ArithmeticTwapToNowResponse>({
   encode: ArithmeticTwapToNowRequest.encode,
   decode: ArithmeticTwapToNowResponse.decode,
   service: "osmosis.twap.v1beta1.Query",
   method: "ArithmeticTwapToNow",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetArithmeticTwapToNow = buildUseQuery<ArithmeticTwapToNowRequest, ArithmeticTwapToNowResponse>({
   builderQueryFn: createGetArithmeticTwapToNow,
diff --git a/__fixtures__/v-next/outputicjs/osmosis/txfees/v1beta1/query.rpc.func.ts b/__fixtures__/v-next/outputicjs/osmosis/txfees/v1beta1/query.rpc.func.ts
index 13cd0b104..da0435dec 100644
--- a/__fixtures__/v-next/outputicjs/osmosis/txfees/v1beta1/query.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/osmosis/txfees/v1beta1/query.rpc.func.ts
@@ -1,45 +1,45 @@
 import { RpcResolver, buildQuery } from "../../../helper-func-types";
 import { buildUseQuery } from "../../../react-query";
 import { QueryFeeTokensRequest, QueryFeeTokensResponse, QueryDenomSpotPriceRequest, QueryDenomSpotPriceResponse, QueryDenomPoolIdRequest, QueryDenomPoolIdResponse, QueryBaseDenomRequest, QueryBaseDenomResponse } from "./query";
-export const createGetFeeTokens = (getRpcInstance: RpcResolver) => buildQuery<QueryFeeTokensRequest, QueryFeeTokensResponse>({
+export const createGetFeeTokens = (clientResolver: RpcResolver) => buildQuery<QueryFeeTokensRequest, QueryFeeTokensResponse>({
   encode: QueryFeeTokensRequest.encode,
   decode: QueryFeeTokensResponse.decode,
   service: "osmosis.txfees.v1beta1.Query",
   method: "FeeTokens",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetFeeTokens = buildUseQuery<QueryFeeTokensRequest, QueryFeeTokensResponse>({
   builderQueryFn: createGetFeeTokens,
   queryKeyPrefix: "FeeTokensQuery"
 });
-export const createGetDenomSpotPrice = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomSpotPriceRequest, QueryDenomSpotPriceResponse>({
+export const createGetDenomSpotPrice = (clientResolver: RpcResolver) => buildQuery<QueryDenomSpotPriceRequest, QueryDenomSpotPriceResponse>({
   encode: QueryDenomSpotPriceRequest.encode,
   decode: QueryDenomSpotPriceResponse.decode,
   service: "osmosis.txfees.v1beta1.Query",
   method: "DenomSpotPrice",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomSpotPrice = buildUseQuery<QueryDenomSpotPriceRequest, QueryDenomSpotPriceResponse>({
   builderQueryFn: createGetDenomSpotPrice,
   queryKeyPrefix: "DenomSpotPriceQuery"
 });
-export const createGetDenomPoolId = (getRpcInstance: RpcResolver) => buildQuery<QueryDenomPoolIdRequest, QueryDenomPoolIdResponse>({
+export const createGetDenomPoolId = (clientResolver: RpcResolver) => buildQuery<QueryDenomPoolIdRequest, QueryDenomPoolIdResponse>({
   encode: QueryDenomPoolIdRequest.encode,
   decode: QueryDenomPoolIdResponse.decode,
   service: "osmosis.txfees.v1beta1.Query",
   method: "DenomPoolId",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDenomPoolId = buildUseQuery<QueryDenomPoolIdRequest, QueryDenomPoolIdResponse>({
   builderQueryFn: createGetDenomPoolId,
   queryKeyPrefix: "DenomPoolIdQuery"
 });
-export const createGetBaseDenom = (getRpcInstance: RpcResolver) => buildQuery<QueryBaseDenomRequest, QueryBaseDenomResponse>({
+export const createGetBaseDenom = (clientResolver: RpcResolver) => buildQuery<QueryBaseDenomRequest, QueryBaseDenomResponse>({
   encode: QueryBaseDenomRequest.encode,
   decode: QueryBaseDenomResponse.decode,
   service: "osmosis.txfees.v1beta1.Query",
   method: "BaseDenom",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBaseDenom = buildUseQuery<QueryBaseDenomRequest, QueryBaseDenomResponse>({
   builderQueryFn: createGetBaseDenom,
diff --git a/__fixtures__/v-next/outputicjs/react-query.ts b/__fixtures__/v-next/outputicjs/react-query.ts
index 35967eb19..365760534 100644
--- a/__fixtures__/v-next/outputicjs/react-query.ts
+++ b/__fixtures__/v-next/outputicjs/react-query.ts
@@ -4,21 +4,25 @@
 * and run the transpile command or npm scripts command that is used to regenerate this bundle.
 */
 
-import { getRpcClient } from './extern'
+
+  import { getRpcClient } from './extern'
 import {
+  isRpc,
   Rpc,
 } from './helpers'
 import {
   ITxArgs,
   ISigningClient,
   StdFee,
-  DeliverTxResponse
+  DeliverTxResponse,
+  SigningClientResolver,
+  RpcResolver,
+  isISigningClient
 } from './helper-func-types'
 import {
     useQuery,
     useQueryClient,
     UseQueryOptions,
-    MutationOptions,
     useMutation,
     UseMutationOptions,
     QueryKey,
@@ -31,15 +35,24 @@ 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 !== null && resolver !== undefined && (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> {
     getter: () => Promise<string | HttpEndpoint>;
     rpcEndPointKey?: string;
@@ -57,20 +70,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');
       }
@@ -82,7 +95,7 @@ export const useRpcClient = <TData = ProtobufRpcClient>({
 };
 
 export interface UseQueryBuilderOptions<TReq, TRes> {
-  builderQueryFn: (getRpcInstance: () => Rpc | undefined) => (request: TReq) => Promise<TRes>,
+  builderQueryFn: (clientResolver: RpcResolver) => (request: TReq) => Promise<TRes>,
   queryKeyPrefix: string,
 }
 
@@ -91,37 +104,52 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
   return <TData = TRes>({
     request,
     options,
-    rpcEndpoint,
-    rpcClientQueryKey,
+    clientResolver,
     customizedQueryKey,
   }: UseQueryParams<TReq, TRes, TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [key];
-    const rpc = queryClient.getQueryData<Rpc>(queryKey);
-    const queryFn = opts.builderQueryFn(()=>{
-      return rpc;
-    });
+
+    let rpcResolver: RpcResolver | undefined;
+
+    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 = clientResolver;
+    }
+
+    if(!rpcResolver) {
+      throw new Error('RpcResolver is not initialized');
+    }
+
+    const queryFn = opts.builderQueryFn(rpcResolver);
     return useQuery<TRes, Error, TData>(customizedQueryKey || [opts.queryKeyPrefix, request], () => queryFn(request), options);
   };
 }
 
 export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
   request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
   customizedQueryKey?: QueryKey
 }
 
 export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
   options?: UseMutationOptions<TData, TError, TVariables, TContext>;
-  rpcEndpoint?: string | HttpEndpoint;
-  signingClientQueryKey?: string;
+  clientResolver?: CacheResolver | SigningClientResolver;
 }
 
 
 export interface UseMutationBuilderOptions<TMsg> {
-  builderMutationFn: (getSigningClientInstance: () => ISigningClient | undefined) => (
+  builderMutationFn: (getSigningClientInstance: SigningClientResolver) => (
     signerAddress: string,
     message: TMsg,
     fee: StdFee | 'auto',
@@ -133,19 +161,29 @@ export interface UseMutationBuilderOptions<TMsg> {
 export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
   return ({
     options,
-    rpcEndpoint,
-    signingClientQueryKey
+    clientResolver
   }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = signingClientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [DEFAULT_SIGNING_CLIENT_QUERY_KEY];
-    const signingClient = queryClient.getQueryData<ISigningClient>(queryKey);
 
-    const mutationFn = opts.builderMutationFn(() => {
-      return signingClient;
-    });
+    let signingClientResolver: SigningClientResolver | undefined;
+
+    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 {
+      clientResolver = clientResolver;
+    }
+
+    if(!signingClientResolver) {
+      throw new Error('SigningClientResolver is not initialized');
+    }
+
+    const mutationFn = opts.builderMutationFn(signingClientResolver);
 
     return useMutation<DeliverTxResponse, Error, ITxArgs<TMsg>>(
       (reqData: ITxArgs<TMsg>) => mutationFn(reqData.signerAddress, reqData.message, reqData.fee, reqData.memo),
diff --git a/__fixtures__/v-next/outputicjs/tendermint/abci/types.rpc.func.ts b/__fixtures__/v-next/outputicjs/tendermint/abci/types.rpc.func.ts
index 534b5fbb3..e359a8673 100644
--- a/__fixtures__/v-next/outputicjs/tendermint/abci/types.rpc.func.ts
+++ b/__fixtures__/v-next/outputicjs/tendermint/abci/types.rpc.func.ts
@@ -1,166 +1,166 @@
 import { RpcResolver, buildQuery } from "../../helper-func-types";
 import { buildUseQuery } from "../../react-query";
 import { RequestEcho, ResponseEcho, RequestFlush, ResponseFlush, RequestInfo, ResponseInfo, RequestSetOption, ResponseSetOption, RequestDeliverTx, ResponseDeliverTx, RequestCheckTx, ResponseCheckTx, RequestQuery, ResponseQuery, RequestCommit, ResponseCommit, RequestInitChain, ResponseInitChain, RequestBeginBlock, ResponseBeginBlock, RequestEndBlock, ResponseEndBlock, RequestListSnapshots, ResponseListSnapshots, RequestOfferSnapshot, ResponseOfferSnapshot, RequestLoadSnapshotChunk, ResponseLoadSnapshotChunk, RequestApplySnapshotChunk, ResponseApplySnapshotChunk } from "./types";
-export const createGetEcho = (getRpcInstance: RpcResolver) => buildQuery<RequestEcho, ResponseEcho>({
+export const createGetEcho = (clientResolver: RpcResolver) => buildQuery<RequestEcho, ResponseEcho>({
   encode: RequestEcho.encode,
   decode: ResponseEcho.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "Echo",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEcho = buildUseQuery<RequestEcho, ResponseEcho>({
   builderQueryFn: createGetEcho,
   queryKeyPrefix: "EchoQuery"
 });
-export const createGetFlush = (getRpcInstance: RpcResolver) => buildQuery<RequestFlush, ResponseFlush>({
+export const createGetFlush = (clientResolver: RpcResolver) => buildQuery<RequestFlush, ResponseFlush>({
   encode: RequestFlush.encode,
   decode: ResponseFlush.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "Flush",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetFlush = buildUseQuery<RequestFlush, ResponseFlush>({
   builderQueryFn: createGetFlush,
   queryKeyPrefix: "FlushQuery"
 });
-export const createGetInfo = (getRpcInstance: RpcResolver) => buildQuery<RequestInfo, ResponseInfo>({
+export const createGetInfo = (clientResolver: RpcResolver) => buildQuery<RequestInfo, ResponseInfo>({
   encode: RequestInfo.encode,
   decode: ResponseInfo.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "Info",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetInfo = buildUseQuery<RequestInfo, ResponseInfo>({
   builderQueryFn: createGetInfo,
   queryKeyPrefix: "InfoQuery"
 });
-export const createGetSetOption = (getRpcInstance: RpcResolver) => buildQuery<RequestSetOption, ResponseSetOption>({
+export const createGetSetOption = (clientResolver: RpcResolver) => buildQuery<RequestSetOption, ResponseSetOption>({
   encode: RequestSetOption.encode,
   decode: ResponseSetOption.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "SetOption",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetSetOption = buildUseQuery<RequestSetOption, ResponseSetOption>({
   builderQueryFn: createGetSetOption,
   queryKeyPrefix: "SetOptionQuery"
 });
-export const createGetDeliverTx = (getRpcInstance: RpcResolver) => buildQuery<RequestDeliverTx, ResponseDeliverTx>({
+export const createGetDeliverTx = (clientResolver: RpcResolver) => buildQuery<RequestDeliverTx, ResponseDeliverTx>({
   encode: RequestDeliverTx.encode,
   decode: ResponseDeliverTx.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "DeliverTx",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetDeliverTx = buildUseQuery<RequestDeliverTx, ResponseDeliverTx>({
   builderQueryFn: createGetDeliverTx,
   queryKeyPrefix: "DeliverTxQuery"
 });
-export const createGetCheckTx = (getRpcInstance: RpcResolver) => buildQuery<RequestCheckTx, ResponseCheckTx>({
+export const createGetCheckTx = (clientResolver: RpcResolver) => buildQuery<RequestCheckTx, ResponseCheckTx>({
   encode: RequestCheckTx.encode,
   decode: ResponseCheckTx.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "CheckTx",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCheckTx = buildUseQuery<RequestCheckTx, ResponseCheckTx>({
   builderQueryFn: createGetCheckTx,
   queryKeyPrefix: "CheckTxQuery"
 });
-export const createGetQuery = (getRpcInstance: RpcResolver) => buildQuery<RequestQuery, ResponseQuery>({
+export const createGetQuery = (clientResolver: RpcResolver) => buildQuery<RequestQuery, ResponseQuery>({
   encode: RequestQuery.encode,
   decode: ResponseQuery.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "Query",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetQuery = buildUseQuery<RequestQuery, ResponseQuery>({
   builderQueryFn: createGetQuery,
   queryKeyPrefix: "QueryQuery"
 });
-export const createGetCommit = (getRpcInstance: RpcResolver) => buildQuery<RequestCommit, ResponseCommit>({
+export const createGetCommit = (clientResolver: RpcResolver) => buildQuery<RequestCommit, ResponseCommit>({
   encode: RequestCommit.encode,
   decode: ResponseCommit.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "Commit",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetCommit = buildUseQuery<RequestCommit, ResponseCommit>({
   builderQueryFn: createGetCommit,
   queryKeyPrefix: "CommitQuery"
 });
-export const createGetInitChain = (getRpcInstance: RpcResolver) => buildQuery<RequestInitChain, ResponseInitChain>({
+export const createGetInitChain = (clientResolver: RpcResolver) => buildQuery<RequestInitChain, ResponseInitChain>({
   encode: RequestInitChain.encode,
   decode: ResponseInitChain.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "InitChain",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetInitChain = buildUseQuery<RequestInitChain, ResponseInitChain>({
   builderQueryFn: createGetInitChain,
   queryKeyPrefix: "InitChainQuery"
 });
-export const createGetBeginBlock = (getRpcInstance: RpcResolver) => buildQuery<RequestBeginBlock, ResponseBeginBlock>({
+export const createGetBeginBlock = (clientResolver: RpcResolver) => buildQuery<RequestBeginBlock, ResponseBeginBlock>({
   encode: RequestBeginBlock.encode,
   decode: ResponseBeginBlock.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "BeginBlock",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetBeginBlock = buildUseQuery<RequestBeginBlock, ResponseBeginBlock>({
   builderQueryFn: createGetBeginBlock,
   queryKeyPrefix: "BeginBlockQuery"
 });
-export const createGetEndBlock = (getRpcInstance: RpcResolver) => buildQuery<RequestEndBlock, ResponseEndBlock>({
+export const createGetEndBlock = (clientResolver: RpcResolver) => buildQuery<RequestEndBlock, ResponseEndBlock>({
   encode: RequestEndBlock.encode,
   decode: ResponseEndBlock.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "EndBlock",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetEndBlock = buildUseQuery<RequestEndBlock, ResponseEndBlock>({
   builderQueryFn: createGetEndBlock,
   queryKeyPrefix: "EndBlockQuery"
 });
-export const createGetListSnapshots = (getRpcInstance: RpcResolver) => buildQuery<RequestListSnapshots, ResponseListSnapshots>({
+export const createGetListSnapshots = (clientResolver: RpcResolver) => buildQuery<RequestListSnapshots, ResponseListSnapshots>({
   encode: RequestListSnapshots.encode,
   decode: ResponseListSnapshots.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "ListSnapshots",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetListSnapshots = buildUseQuery<RequestListSnapshots, ResponseListSnapshots>({
   builderQueryFn: createGetListSnapshots,
   queryKeyPrefix: "ListSnapshotsQuery"
 });
-export const createGetOfferSnapshot = (getRpcInstance: RpcResolver) => buildQuery<RequestOfferSnapshot, ResponseOfferSnapshot>({
+export const createGetOfferSnapshot = (clientResolver: RpcResolver) => buildQuery<RequestOfferSnapshot, ResponseOfferSnapshot>({
   encode: RequestOfferSnapshot.encode,
   decode: ResponseOfferSnapshot.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "OfferSnapshot",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetOfferSnapshot = buildUseQuery<RequestOfferSnapshot, ResponseOfferSnapshot>({
   builderQueryFn: createGetOfferSnapshot,
   queryKeyPrefix: "OfferSnapshotQuery"
 });
-export const createGetLoadSnapshotChunk = (getRpcInstance: RpcResolver) => buildQuery<RequestLoadSnapshotChunk, ResponseLoadSnapshotChunk>({
+export const createGetLoadSnapshotChunk = (clientResolver: RpcResolver) => buildQuery<RequestLoadSnapshotChunk, ResponseLoadSnapshotChunk>({
   encode: RequestLoadSnapshotChunk.encode,
   decode: ResponseLoadSnapshotChunk.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "LoadSnapshotChunk",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetLoadSnapshotChunk = buildUseQuery<RequestLoadSnapshotChunk, ResponseLoadSnapshotChunk>({
   builderQueryFn: createGetLoadSnapshotChunk,
   queryKeyPrefix: "LoadSnapshotChunkQuery"
 });
-export const createGetApplySnapshotChunk = (getRpcInstance: RpcResolver) => buildQuery<RequestApplySnapshotChunk, ResponseApplySnapshotChunk>({
+export const createGetApplySnapshotChunk = (clientResolver: RpcResolver) => buildQuery<RequestApplySnapshotChunk, ResponseApplySnapshotChunk>({
   encode: RequestApplySnapshotChunk.encode,
   decode: ResponseApplySnapshotChunk.decode,
   service: "tendermint.abci.ABCIApplication",
   method: "ApplySnapshotChunk",
-  getRpcInstance: getRpcInstance
+  clientResolver
 });
 export const useGetApplySnapshotChunk = buildUseQuery<RequestApplySnapshotChunk, ResponseApplySnapshotChunk>({
   builderQueryFn: createGetApplySnapshotChunk,
diff --git a/__fixtures__/v-next/outputinstantrpc/helpers.ts b/__fixtures__/v-next/outputinstantrpc/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputinstantrpc/helpers.ts
+++ b/__fixtures__/v-next/outputinstantrpc/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputosmojs/helpers.ts b/__fixtures__/v-next/outputosmojs/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputosmojs/helpers.ts
+++ b/__fixtures__/v-next/outputosmojs/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputsign/helpers.ts b/__fixtures__/v-next/outputsign/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputsign/helpers.ts
+++ b/__fixtures__/v-next/outputsign/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputv2/helpers.ts b/__fixtures__/v-next/outputv2/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputv2/helpers.ts
+++ b/__fixtures__/v-next/outputv2/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputv3/helpers.ts b/__fixtures__/v-next/outputv3/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputv3/helpers.ts
+++ b/__fixtures__/v-next/outputv3/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/__fixtures__/v-next/outputv4/helpers.ts b/__fixtures__/v-next/outputv4/helpers.ts
index 091dfcca7..c78a8db51 100644
--- a/__fixtures__/v-next/outputv4/helpers.ts
+++ b/__fixtures__/v-next/outputv4/helpers.ts
@@ -198,6 +198,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/packages/ast/src/clients/helper-funcs/__snapshots__/funcs.test.ts.snap b/packages/ast/src/clients/helper-funcs/__snapshots__/funcs.test.ts.snap
index 8601c80d4..37cd1b0f4 100644
--- a/packages/ast/src/clients/helper-funcs/__snapshots__/funcs.test.ts.snap
+++ b/packages/ast/src/clients/helper-funcs/__snapshots__/funcs.test.ts.snap
@@ -1,8 +1,8 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`msg funcs works 1`] = `
-"export const createSend = (getSigningClient: SigningClientResolver) => buildTx<MsgSend>({
-  getSigningClient: getSigningClient,
+"export const createSend = (clientResolver: SigningClientResolver) => buildTx<MsgSend>({
+  clientResolver,
   typeUrl: MsgSend.typeUrl,
   encoders: toEncoders(MsgSend),
   converters: toConverters(MsgSend)
@@ -16,12 +16,12 @@ exports[`msg funcs works 2`] = `
 `;
 
 exports[`query funcs works 1`] = `
-"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
 });"
 `;
 
diff --git a/packages/ast/src/clients/helper-funcs/msg-funcs.ts b/packages/ast/src/clients/helper-funcs/msg-funcs.ts
index 0ed7f0d29..e8ff01487 100644
--- a/packages/ast/src/clients/helper-funcs/msg-funcs.ts
+++ b/packages/ast/src/clients/helper-funcs/msg-funcs.ts
@@ -25,8 +25,10 @@ export function createMsgHelperCreator(
     const callExpression = ast.callExpression(ast.identifier("buildTx"), [
         ast.objectExpression([
             ast.objectProperty(
-                ast.identifier("getSigningClient"),
-                ast.identifier("getSigningClient")
+                ast.identifier("clientResolver"),
+                ast.identifier("clientResolver"),
+                false,
+                true
             ),
             ast.objectProperty(
                 ast.identifier("typeUrl"),
@@ -55,7 +57,7 @@ export function createMsgHelperCreator(
     const customHookArgumentsType = ast.tsTypeAnnotation(
         ast.tsTypeReference(ast.identifier("SigningClientResolver"))
     );
-    const arg = ast.identifier("getSigningClient");
+    const arg = ast.identifier("clientResolver");
     arg.typeAnnotation = customHookArgumentsType;
     const arrowFuncExp = ast.arrowFunctionExpression([arg], callExpression);
     return ast.exportNamedDeclaration(
diff --git a/packages/ast/src/clients/helper-funcs/query-funcs.ts b/packages/ast/src/clients/helper-funcs/query-funcs.ts
index 586f2163a..fb048793e 100644
--- a/packages/ast/src/clients/helper-funcs/query-funcs.ts
+++ b/packages/ast/src/clients/helper-funcs/query-funcs.ts
@@ -46,8 +46,9 @@ export function createQueryHelperCreator(
                 ast.stringLiteral(methodKey)
             ),
             ast.objectProperty(
-                ast.identifier("getRpcInstance"),
-                ast.identifier("getRpcInstance")
+                ast.identifier("clientResolver"),
+                ast.identifier("clientResolver"),
+                false, true
             ),
         ]),
     ]);
@@ -59,7 +60,7 @@ export function createQueryHelperCreator(
     const customHookArgumentsType = ast.tsTypeAnnotation(
         ast.tsTypeReference(ast.identifier("RpcResolver"))
     );
-    const arg = ast.identifier("getRpcInstance");
+    const arg = ast.identifier("clientResolver");
     arg.typeAnnotation = customHookArgumentsType;
 
     const arrowFuncExp = ast.arrowFunctionExpression([arg], callExpression);
diff --git a/packages/telescope/src/helpers/helper-func-types.ts b/packages/telescope/src/helpers/helper-func-types.ts
index 0d9ddeb41..b2e2d58a0 100644
--- a/packages/telescope/src/helpers/helper-func-types.ts
+++ b/packages/telescope/src/helpers/helper-func-types.ts
@@ -1,21 +1,29 @@
 import { TelescopeOptions } from "@cosmology/types";
 
-export const getHelperFuncTypes = (_: TelescopeOptions) => {
+export const getHelperFuncTypes = (options: TelescopeOptions) => {
   return `
-import { BinaryReader, BinaryWriter } from "./binary";
-import { Rpc } from "./helpers";
+import { HttpEndpoint } from "@interchainjs/types";
+import { BinaryReader, BinaryWriter } from "./binary${options.restoreImportExtension ?? ""}";
+import { getRpcClient } from "./extern${options.restoreImportExtension ?? ""}";
+import { isRpc, Rpc } from "./helpers${options.restoreImportExtension ?? ""}";
 
 export interface QueryBuilderOptions<TReq, TRes> {
   encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter
   decode: (input: BinaryReader | Uint8Array, length?: number) => TRes
   service: string,
   method: string,
-  getRpcInstance: () => Rpc | undefined
+  clientResolver: RpcResolver
 }
 
 export function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>) {
     return async (request: TReq) => {
-      const rpc = opts.getRpcInstance();
+      let rpc: Rpc | undefined;
+
+      if(isRpc(opts.clientResolver)) {
+        rpc = opts.clientResolver;
+      } else {
+        rpc = await getRpcClient(opts.clientResolver);
+      }
 
       if (!rpc) throw new Error("Query Rpc is not initialized");
 
@@ -32,6 +40,13 @@ export interface ITxArgs<TMsg> {
   memo: string;
 }
 
+export function isISigningClient(client: unknown): client is ISigningClient {
+  return client !== null && client !== undefined
+    && typeof (client as ISigningClient).signAndBroadcast === 'function'
+    && typeof (client as ISigningClient).addConverters === 'function'
+    && typeof (client as ISigningClient).addEncoders === 'function';
+}
+
 export interface ISigningClient {
   /**
    * register converters
@@ -51,7 +66,7 @@ export interface ISigningClient {
 }
 
 export interface TxBuilderOptions {
-  getSigningClient: () => ISigningClient | undefined,
+  clientResolver: SigningClientResolver,
   typeUrl: string,
   encoders?: Encoder[],
   converters?: AminoConverter[],
@@ -64,7 +79,12 @@ export function buildTx<TMsg>(opts: TxBuilderOptions) {
     fee: StdFee | 'auto',
     memo: string
   ): Promise<DeliverTxResponse> => {
-    const client = opts.getSigningClient();
+    let client: ISigningClient | undefined;
+
+    // if opts.getSigningClient is a function, call it to get the SigningClient instance
+    if(isISigningClient(opts.clientResolver)) {
+      client = opts.clientResolver;
+    }
 
     if (!client) throw new Error("SigningClient is not initialized");
 
@@ -164,7 +184,7 @@ export interface AminoConverter {
   toAmino: (data: any) => any;
 }
 
-export type SigningClientResolver = () => ISigningClient | undefined;
-export type RpcResolver = () => Rpc | undefined;
+export type SigningClientResolver = string | HttpEndpoint | ISigningClient;
+export type RpcResolver = string | HttpEndpoint | Rpc ;
 `;
 };
diff --git a/packages/telescope/src/helpers/internal-for-bigint.ts b/packages/telescope/src/helpers/internal-for-bigint.ts
index f7daa3dd4..635313020 100644
--- a/packages/telescope/src/helpers/internal-for-bigint.ts
+++ b/packages/telescope/src/helpers/internal-for-bigint.ts
@@ -197,6 +197,10 @@ export interface Rpc {
   ): Promise<Uint8Array>;
 }
 
+export function isRpc(rpc: unknown): rpc is Rpc {
+  return rpc !== null && rpc !== undefined && typeof (rpc as Rpc).request === 'function';
+}
+
 interface Timestamp {
   /**
    * Represents seconds of UTC time since Unix epoch
diff --git a/packages/telescope/src/helpers/react-query-hooks-icjs.ts b/packages/telescope/src/helpers/react-query-hooks-icjs.ts
index 13cf16860..23965b71a 100644
--- a/packages/telescope/src/helpers/react-query-hooks-icjs.ts
+++ b/packages/telescope/src/helpers/react-query-hooks-icjs.ts
@@ -1,42 +1,55 @@
 import { TelescopeOptions } from "@cosmology/types";
 
 export const getReactQueryHelperHooksIcJs = (options: TelescopeOptions) => {
-  return `import { getRpcClient } from './extern${options.restoreImportExtension ?? ""}'
+  return `
+  import { getRpcClient } from './extern${options.restoreImportExtension ?? ""}'
 import {
+  isRpc,
   Rpc,
 } from './helpers${options.restoreImportExtension ?? ""}'
 import {
   ITxArgs,
   ISigningClient,
   StdFee,
-  DeliverTxResponse
+  DeliverTxResponse,
+  SigningClientResolver,
+  RpcResolver,
+  isISigningClient
 } from './helper-func-types${options.restoreImportExtension ?? ""}'
 import {
     useQuery,
     useQueryClient,
     UseQueryOptions,
-    MutationOptions,
     useMutation,
     UseMutationOptions,
     QueryKey,
 } from '@tanstack/react-query';
 
 import { HttpEndpoint } from "@interchainjs/types";
-import { Rpc as ProtobufRpcClient } from "./helpers";
+import { Rpc as ProtobufRpcClient } from "./helpers${options.restoreImportExtension ?? ""}";
 
 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 !== null && resolver !== undefined && (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;
 }
 
+
 ${
   options.reactQuery.needExtraQueryKey
     ? `export interface UseRpcEndpointQuery<TData> extends ReactQueryParams<string | HttpEndpoint, TData> {
@@ -74,20 +87,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');
       }
@@ -99,7 +112,7 @@ export const useRpcClient = <TData = ProtobufRpcClient>({
 };
 
 export interface UseQueryBuilderOptions<TReq, TRes> {
-  builderQueryFn: (getRpcInstance: () => Rpc | undefined) => (request: TReq) => Promise<TRes>,
+  builderQueryFn: (clientResolver: RpcResolver) => (request: TReq) => Promise<TRes>,
   queryKeyPrefix: string,
 }
 
@@ -108,37 +121,52 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
   return <TData = TRes>({
     request,
     options,
-    rpcEndpoint,
-    rpcClientQueryKey,
+    clientResolver,
     customizedQueryKey,
   }: UseQueryParams<TReq, TRes, TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [key];
-    const rpc = queryClient.getQueryData<Rpc>(queryKey);
-    const queryFn = opts.builderQueryFn(()=>{
-      return rpc;
-    });
+
+    let rpcResolver: RpcResolver | undefined;
+
+    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 = clientResolver;
+    }
+
+    if(!rpcResolver) {
+      throw new Error('RpcResolver is not initialized');
+    }
+
+    const queryFn = opts.builderQueryFn(rpcResolver);
     return useQuery<TRes, Error, TData>(customizedQueryKey || [opts.queryKeyPrefix, request], () => queryFn(request), options);
   };
 }
 
 export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
   request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
   customizedQueryKey?: QueryKey
 }
 
 export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
   options?: UseMutationOptions<TData, TError, TVariables, TContext>;
-  rpcEndpoint?: string | HttpEndpoint;
-  signingClientQueryKey?: string;
+  clientResolver?: CacheResolver | SigningClientResolver;
 }
 
 
 export interface UseMutationBuilderOptions<TMsg> {
-  builderMutationFn: (getSigningClientInstance: () => ISigningClient | undefined) => (
+  builderMutationFn: (getSigningClientInstance: SigningClientResolver) => (
     signerAddress: string,
     message: TMsg,
     fee: StdFee | 'auto',
@@ -150,19 +178,29 @@ export interface UseMutationBuilderOptions<TMsg> {
 export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
   return ({
     options,
-    rpcEndpoint,
-    signingClientQueryKey
+    clientResolver
   }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = signingClientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [DEFAULT_SIGNING_CLIENT_QUERY_KEY];
-    const signingClient = queryClient.getQueryData<ISigningClient>(queryKey);
 
-    const mutationFn = opts.builderMutationFn(() => {
-      return signingClient;
-    });
+    let signingClientResolver: SigningClientResolver | undefined;
+
+    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 {
+      clientResolver = clientResolver;
+    }
+
+    if(!signingClientResolver) {
+      throw new Error('SigningClientResolver is not initialized');
+    }
+
+    const mutationFn = opts.builderMutationFn(signingClientResolver);
 
     return useMutation<DeliverTxResponse, Error, ITxArgs<TMsg>>(
       (reqData: ITxArgs<TMsg>) => mutationFn(reqData.signerAddress, reqData.message, reqData.fee, reqData.memo),
diff --git a/packages/telescope/src/helpers/react-query-hooks.ts b/packages/telescope/src/helpers/react-query-hooks.ts
index e935e134b..ec8a4106f 100644
--- a/packages/telescope/src/helpers/react-query-hooks.ts
+++ b/packages/telescope/src/helpers/react-query-hooks.ts
@@ -1,21 +1,27 @@
 import { TelescopeOptions } from "@cosmology/types";
 
 export const getReactQueryHelperHooks = (options: TelescopeOptions) => {
-  return `import { getRpcClient } from './extern${options.restoreImportExtension ?? ""}'
+  return `
+
+
+import { getRpcClient } from './extern${options.restoreImportExtension ?? ""}'
 import {
+  isRpc,
   Rpc,
-} from './helpers'
+} from './helpers${options.restoreImportExtension ?? ""}'
 import {
   ITxArgs,
   ISigningClient,
   StdFee,
-  DeliverTxResponse
-} from './helper-func-types'
+  DeliverTxResponse,
+  SigningClientResolver,
+  RpcResolver,
+  isISigningClient
+} from './helper-func-types${options.restoreImportExtension ?? ""}'
 import {
     useQuery,
     useQueryClient,
     UseQueryOptions,
-    MutationOptions,
     useMutation,
     UseMutationOptions,
     QueryKey,
@@ -32,13 +38,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 !== null && resolver !== undefined && (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;
 }
 
 ${
@@ -78,20 +92,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');
       }
@@ -140,7 +154,7 @@ ${
 };
 
 export interface UseQueryBuilderOptions<TReq, TRes> {
-  builderQueryFn: (getRpcInstance: () => Rpc | undefined) => (request: TReq) => Promise<TRes>,
+  builderQueryFn: (clientResolver: RpcResolver) => (request: TReq) => Promise<TRes>,
   queryKeyPrefix: string,
 }
 
@@ -149,37 +163,52 @@ export function buildUseQuery<TReq, TRes>(opts: UseQueryBuilderOptions<TReq, TRe
   return <TData = TRes>({
     request,
     options,
-    rpcEndpoint,
-    rpcClientQueryKey,
+    clientResolver,
     customizedQueryKey,
   }: UseQueryParams<TReq, TRes, TData>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = rpcClientQueryKey || DEFAULT_RPC_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [key];
-    const rpc = queryClient.getQueryData<Rpc>(queryKey);
-    const queryFn = opts.builderQueryFn(()=>{
-      return rpc;
-    });
+
+    let rpcResolver: RpcResolver | undefined;
+
+    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 = clientResolver;
+    }
+
+    if(!rpcResolver) {
+      throw new Error('RpcResolver is not initialized');
+    }
+
+    const queryFn = opts.builderQueryFn(rpcResolver);
     return useQuery<TRes, Error, TData>(customizedQueryKey || [opts.queryKeyPrefix, request], () => queryFn(request), options);
   };
 }
 
 export interface UseQueryParams<TReq, TRes, TData = TRes> extends ReactQueryParams<TRes, TData> {
   request: TReq;
+  clientResolver?: CacheResolver | RpcResolver;
   customizedQueryKey?: QueryKey
 }
 
 export interface ReactMutationParams<TData, TError, TVariables, TContext = unknown> {
   options?: UseMutationOptions<TData, TError, TVariables, TContext>;
-  rpcEndpoint?: string | HttpEndpoint;
-  signingClientQueryKey?: string;
+  clientResolver?: CacheResolver | SigningClientResolver;
 }
 
 
 export interface UseMutationBuilderOptions<TMsg> {
-  builderMutationFn: (getSigningClientInstance: () => ISigningClient | undefined) => (
+  builderMutationFn: (getSigningClientInstance: SigningClientResolver) => (
     signerAddress: string,
     message: TMsg,
     fee: StdFee | 'auto',
@@ -191,19 +220,29 @@ export interface UseMutationBuilderOptions<TMsg> {
 export function buildUseMutation<TMsg, TError>(opts: UseMutationBuilderOptions<TMsg>) {
   return ({
     options,
-    rpcEndpoint,
-    signingClientQueryKey
+    clientResolver
   }: ReactMutationParams<DeliverTxResponse, TError, ITxArgs<TMsg>>) => {
     const queryClient = useQueryClient({
       context: options?.context
     });
-    const key = signingClientQueryKey || DEFAULT_SIGNING_CLIENT_QUERY_KEY;
-    const queryKey = rpcEndpoint ? [key, rpcEndpoint] : [DEFAULT_SIGNING_CLIENT_QUERY_KEY];
-    const signingClient = queryClient.getQueryData<ISigningClient>(queryKey);
 
-    const mutationFn = opts.builderMutationFn(() => {
-      return signingClient;
-    });
+    let signingClientResolver: SigningClientResolver | undefined;
+
+    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 {
+      clientResolver = clientResolver;
+    }
+
+    if(!signingClientResolver) {
+      throw new Error('SigningClientResolver is not initialized');
+    }
+
+    const mutationFn = opts.builderMutationFn(signingClientResolver);
 
     return useMutation<DeliverTxResponse, Error, ITxArgs<TMsg>>(
       (reqData: ITxArgs<TMsg>) => mutationFn(reqData.signerAddress, reqData.message, reqData.fee, reqData.memo),
diff --git a/packages/telescope/types/helpers/helper-func-types.d.ts b/packages/telescope/types/helpers/helper-func-types.d.ts
index 024eee9e4..290bfec6f 100644
--- a/packages/telescope/types/helpers/helper-func-types.d.ts
+++ b/packages/telescope/types/helpers/helper-func-types.d.ts
@@ -1,2 +1,2 @@
 import { TelescopeOptions } from "@cosmology/types";
-export declare const getHelperFuncTypes: (_: TelescopeOptions) => string;
+export declare const getHelperFuncTypes: (options: TelescopeOptions) => string;