@xpla/xplajs 1.7.0 → 1.8.0-rc.0

package/esm/ibc/core/commitment/v2/commitment.js

@@ -0,0 +1,118 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseMerklePath() {
+    return {
+        keyPath: []
+    };
+}
+/**
+ * MerklePath is the path used to verify commitment proofs, which can be an
+ * arbitrary structured object (defined by a commitment type).
+ * ICS-23 verification supports membership proofs for nested merkle trees.
+ * The ICS-24 standard provable keys MUST be stored in the lowest level tree with an optional prefix.
+ * The IC24 provable tree may then be stored in a higher level tree(s) that hash up to the root hash
+ * stored in the consensus state of the client.
+ * Each element of the path represents the key of a merkle tree from the root to the leaf.
+ * The elements of the path before the final element must be the path to the tree that contains
+ * the ICS24 provable store. Thus, it should remain constant for all ICS24 proofs.
+ * The final element of the path is the key of the leaf in the ICS24 provable store,
+ * Thus IBC core will append the ICS24 path to the final element of the MerklePath
+ * stored in the counterparty to create the full path to the leaf for proof verification.
+ * Examples:
+ * Cosmos SDK:
+ * The Cosmos SDK commits to a multi-tree where each store is an IAVL tree and all store hashes
+ * are hashed in a simple merkle tree to get the final root hash. Thus, the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["ibc", ""]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["ibc", "{packetCommitmentPath}"] which will then be used for final verification.
+ * Ethereum:
+ * The Ethereum client commits to a single Patricia merkle trie. The ICS24 provable store is managed
+ * by the smart contract state. Each smart contract has a specific prefix reserved within the global trie.
+ * Thus the MerklePath in the counterparty is the prefix to the smart contract state in the global trie.
+ * Since there is only one tree in the commitment structure of ethereum the MerklePath in the counterparty
+ * MerklePrefix has the following structure: ["IBCCoreContractAddressStoragePrefix"]
+ * The core IBC handler will append the ICS24 path to the final element of the MerklePath
+ * like so: ["IBCCoreContractAddressStoragePrefix{packetCommitmentPath}"] which will then be used for final
+ * verification. Thus the MerklePath in the counterparty MerklePrefix is the nested key path from the root hash of the
+ * consensus state down to the ICS24 provable store. The IBC handler retrieves the counterparty key path to the ICS24
+ * provable store from the MerklePath and appends the ICS24 path to get the final key path to the value being verified
+ * by the client against the root hash in the client's consensus state.
+ * @name MerklePath
+ * @package ibc.core.commitment.v2
+ * @see proto type: ibc.core.commitment.v2.MerklePath
+ */
+export const MerklePath = {
+    typeUrl: "/ibc.core.commitment.v2.MerklePath",
+    aminoType: "cosmos-sdk/MerklePath",
+    is(o) {
+        return o && (o.$typeUrl === MerklePath.typeUrl || Array.isArray(o.keyPath) && (!o.keyPath.length || o.keyPath[0] instanceof Uint8Array || typeof o.keyPath[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MerklePath.typeUrl || Array.isArray(o.key_path) && (!o.key_path.length || o.key_path[0] instanceof Uint8Array || typeof o.key_path[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.keyPath) {
+            writer.uint32(10).bytes(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerklePath();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.keyPath.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMerklePath();
+        message.keyPath = object.keyPath?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMerklePath();
+        message.keyPath = object.key_path?.map(e => bytesFromBase64(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.keyPath) {
+            obj.key_path = message.keyPath.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.key_path = message.keyPath;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MerklePath.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MerklePath",
+            value: MerklePath.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MerklePath.decode(message.value);
+    },
+    toProto(message) {
+        return MerklePath.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.commitment.v2.MerklePath",
+            value: MerklePath.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/esm/ibc/core/connection/v1/connection.js

@@ -1,6 +1,7 @@
 import { MerklePrefix } from "../../commitment/v1/commitment";
 import { isSet } from "../../../../helpers";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
 /**
  * State defines if a connection is in one of the following states:
  * INIT, TRYOPEN, OPEN or UNINITIALIZED.
@@ -65,6 +66,15 @@ function createBaseConnectionEnd() {
         delayPeriod: BigInt(0)
     };
 }
+/**
+ * ConnectionEnd defines a stateful object on a chain connected to another
+ * separate one.
+ * NOTE: there must only be 2 defined ConnectionEnds to establish
+ * a connection between two chains.
+ * @name ConnectionEnd
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.ConnectionEnd
+ */
 export const ConnectionEnd = {
     typeUrl: "/ibc.core.connection.v1.ConnectionEnd",
     aminoType: "cosmos-sdk/ConnectionEnd",
@@ -183,6 +193,9 @@ export const ConnectionEnd = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(ConnectionEnd.typeUrl)) {
+            return;
+        }
         Version.registerTypeUrl();
         Counterparty.registerTypeUrl();
     }
@@ -197,6 +210,13 @@ function createBaseIdentifiedConnection() {
         delayPeriod: BigInt(0)
     };
 }
+/**
+ * IdentifiedConnection defines a connection with additional connection
+ * identifier field.
+ * @name IdentifiedConnection
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.IdentifiedConnection
+ */
 export const IdentifiedConnection = {
     typeUrl: "/ibc.core.connection.v1.IdentifiedConnection",
     aminoType: "cosmos-sdk/IdentifiedConnection",
@@ -326,6 +346,9 @@ export const IdentifiedConnection = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(IdentifiedConnection.typeUrl)) {
+            return;
+        }
         Version.registerTypeUrl();
         Counterparty.registerTypeUrl();
     }
@@ -337,6 +360,12 @@ function createBaseCounterparty() {
         prefix: MerklePrefix.fromPartial({})
     };
 }
+/**
+ * Counterparty defines the counterparty chain associated with a connection end.
+ * @name Counterparty
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.Counterparty
+ */
 export const Counterparty = {
     typeUrl: "/ibc.core.connection.v1.Counterparty",
     aminoType: "cosmos-sdk/Counterparty",
@@ -430,6 +459,9 @@ export const Counterparty = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Counterparty.typeUrl)) {
+            return;
+        }
         MerklePrefix.registerTypeUrl();
     }
 };
@@ -438,6 +470,12 @@ function createBaseClientPaths() {
         paths: []
     };
 }
+/**
+ * ClientPaths define all the connection paths for a client state.
+ * @name ClientPaths
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.ClientPaths
+ */
 export const ClientPaths = {
     typeUrl: "/ibc.core.connection.v1.ClientPaths",
     aminoType: "cosmos-sdk/ClientPaths",
@@ -519,6 +557,12 @@ function createBaseConnectionPaths() {
         paths: []
     };
 }
+/**
+ * ConnectionPaths define all the connection paths for a given client state.
+ * @name ConnectionPaths
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.ConnectionPaths
+ */
 export const ConnectionPaths = {
     typeUrl: "/ibc.core.connection.v1.ConnectionPaths",
     aminoType: "cosmos-sdk/ConnectionPaths",
@@ -611,6 +655,13 @@ function createBaseVersion() {
         features: []
     };
 }
+/**
+ * Version defines the versioning scheme used to negotiate the IBC version in
+ * the connection handshake.
+ * @name Version
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.Version
+ */
 export const Version = {
     typeUrl: "/ibc.core.connection.v1.Version",
     aminoType: "cosmos-sdk/Version",
@@ -702,6 +753,12 @@ function createBaseParams() {
         maxExpectedTimePerBlock: BigInt(0)
     };
 }
+/**
+ * Params defines the set of Connection parameters.
+ * @name Params
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.Params
+ */
 export const Params = {
     typeUrl: "/ibc.core.connection.v1.Params",
     aminoType: "cosmos-sdk/Params",

package/esm/ibc/core/connection/v1/genesis.js

@@ -1,5 +1,6 @@
 import { IdentifiedConnection, ConnectionPaths, Params } from "./connection";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseGenesisState() {
     return {
         connections: [],
@@ -8,6 +9,12 @@ function createBaseGenesisState() {
         params: Params.fromPartial({})
     };
 }
+/**
+ * GenesisState defines the ibc connection submodule's genesis state.
+ * @name GenesisState
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.GenesisState
+ */
 export const GenesisState = {
     typeUrl: "/ibc.core.connection.v1.GenesisState",
     aminoType: "cosmos-sdk/GenesisState",
@@ -118,6 +125,9 @@ export const GenesisState = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(GenesisState.typeUrl)) {
+            return;
+        }
         IdentifiedConnection.registerTypeUrl();
         ConnectionPaths.registerTypeUrl();
         Params.registerTypeUrl();

package/esm/ibc/core/connection/v1/query.js

@@ -4,11 +4,19 @@ import { Height, IdentifiedClientState, Params } from "../../client/v1/client";
 import { Any } from "../../../../google/protobuf/any";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
 function createBaseQueryConnectionRequest() {
     return {
         connectionId: ""
     };
 }
+/**
+ * QueryConnectionRequest is the request type for the Query/Connection RPC
+ * method
+ * @name QueryConnectionRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionRequest
+ */
 export const QueryConnectionRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionRequest",
     aminoType: "cosmos-sdk/QueryConnectionRequest",
@@ -88,6 +96,14 @@ function createBaseQueryConnectionResponse() {
         proofHeight: Height.fromPartial({})
     };
 }
+/**
+ * QueryConnectionResponse is the response type for the Query/Connection RPC
+ * method. Besides the connection end, it includes a proof and the height from
+ * which the proof was retrieved.
+ * @name QueryConnectionResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionResponse
+ */
 export const QueryConnectionResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionResponse",
     aminoType: "cosmos-sdk/QueryConnectionResponse",
@@ -181,6 +197,9 @@ export const QueryConnectionResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionResponse.typeUrl)) {
+            return;
+        }
         ConnectionEnd.registerTypeUrl();
         Height.registerTypeUrl();
     }
@@ -190,6 +209,13 @@ function createBaseQueryConnectionsRequest() {
         pagination: undefined
     };
 }
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ * @name QueryConnectionsRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionsRequest
+ */
 export const QueryConnectionsRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionsRequest",
     aminoType: "cosmos-sdk/QueryConnectionsRequest",
@@ -261,6 +287,9 @@ export const QueryConnectionsRequest = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionsRequest.typeUrl)) {
+            return;
+        }
         PageRequest.registerTypeUrl();
     }
 };
@@ -271,6 +300,13 @@ function createBaseQueryConnectionsResponse() {
         height: Height.fromPartial({})
     };
 }
+/**
+ * QueryConnectionsResponse is the response type for the Query/Connections RPC
+ * method.
+ * @name QueryConnectionsResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionsResponse
+ */
 export const QueryConnectionsResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionsResponse",
     aminoType: "cosmos-sdk/QueryConnectionsResponse",
@@ -367,6 +403,9 @@ export const QueryConnectionsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionsResponse.typeUrl)) {
+            return;
+        }
         IdentifiedConnection.registerTypeUrl();
         PageResponse.registerTypeUrl();
         Height.registerTypeUrl();
@@ -377,6 +416,13 @@ function createBaseQueryClientConnectionsRequest() {
         clientId: ""
     };
 }
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ * @name QueryClientConnectionsRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryClientConnectionsRequest
+ */
 export const QueryClientConnectionsRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsRequest",
     aminoType: "cosmos-sdk/QueryClientConnectionsRequest",
@@ -456,6 +502,13 @@ function createBaseQueryClientConnectionsResponse() {
         proofHeight: Height.fromPartial({})
     };
 }
+/**
+ * QueryClientConnectionsResponse is the response type for the
+ * Query/ClientConnections RPC method
+ * @name QueryClientConnectionsResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryClientConnectionsResponse
+ */
 export const QueryClientConnectionsResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsResponse",
     aminoType: "cosmos-sdk/QueryClientConnectionsResponse",
@@ -552,6 +605,9 @@ export const QueryClientConnectionsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryClientConnectionsResponse.typeUrl)) {
+            return;
+        }
         Height.registerTypeUrl();
     }
 };
@@ -560,6 +616,13 @@ function createBaseQueryConnectionClientStateRequest() {
         connectionId: ""
     };
 }
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ * @name QueryConnectionClientStateRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionClientStateRequest
+ */
 export const QueryConnectionClientStateRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateRequest",
     aminoType: "cosmos-sdk/QueryConnectionClientStateRequest",
@@ -639,6 +702,13 @@ function createBaseQueryConnectionClientStateResponse() {
         proofHeight: Height.fromPartial({})
     };
 }
+/**
+ * QueryConnectionClientStateResponse is the response type for the
+ * Query/ConnectionClientState RPC method
+ * @name QueryConnectionClientStateResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionClientStateResponse
+ */
 export const QueryConnectionClientStateResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateResponse",
     aminoType: "cosmos-sdk/QueryConnectionClientStateResponse",
@@ -732,6 +802,9 @@ export const QueryConnectionClientStateResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionClientStateResponse.typeUrl)) {
+            return;
+        }
         IdentifiedClientState.registerTypeUrl();
         Height.registerTypeUrl();
     }
@@ -743,6 +816,13 @@ function createBaseQueryConnectionConsensusStateRequest() {
         revisionHeight: BigInt(0)
     };
 }
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ * @name QueryConnectionConsensusStateRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionConsensusStateRequest
+ */
 export const QueryConnectionConsensusStateRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest",
     aminoType: "cosmos-sdk/QueryConnectionConsensusStateRequest",
@@ -845,6 +925,13 @@ function createBaseQueryConnectionConsensusStateResponse() {
         proofHeight: Height.fromPartial({})
     };
 }
+/**
+ * QueryConnectionConsensusStateResponse is the response type for the
+ * Query/ConnectionConsensusState RPC method
+ * @name QueryConnectionConsensusStateResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionConsensusStateResponse
+ */
 export const QueryConnectionConsensusStateResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse",
     aminoType: "cosmos-sdk/QueryConnectionConsensusStateResponse",
@@ -949,12 +1036,21 @@ export const QueryConnectionConsensusStateResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionConsensusStateResponse.typeUrl)) {
+            return;
+        }
         Height.registerTypeUrl();
     }
 };
 function createBaseQueryConnectionParamsRequest() {
     return {};
 }
+/**
+ * QueryConnectionParamsRequest is the request type for the Query/ConnectionParams RPC method.
+ * @name QueryConnectionParamsRequest
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionParamsRequest
+ */
 export const QueryConnectionParamsRequest = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsRequest",
     aminoType: "cosmos-sdk/QueryConnectionParamsRequest",
@@ -1021,6 +1117,12 @@ function createBaseQueryConnectionParamsResponse() {
         params: undefined
     };
 }
+/**
+ * QueryConnectionParamsResponse is the response type for the Query/ConnectionParams RPC method.
+ * @name QueryConnectionParamsResponse
+ * @package ibc.core.connection.v1
+ * @see proto type: ibc.core.connection.v1.QueryConnectionParamsResponse
+ */
 export const QueryConnectionParamsResponse = {
     typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsResponse",
     aminoType: "cosmos-sdk/QueryConnectionParamsResponse",
@@ -1092,6 +1194,9 @@ export const QueryConnectionParamsResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryConnectionParamsResponse.typeUrl)) {
+            return;
+        }
         Params.registerTypeUrl();
     }
 };

package/esm/ibc/core/connection/v1/query.rpc.func.js

@@ -1,50 +1,83 @@
 import { buildQuery } from "../../../../helper-func-types";
 import { QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse, QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse, QueryConnectionParamsRequest, QueryConnectionParamsResponse } from "./query";
-export const createGetConnection = (clientResolver) => buildQuery({
+/**
+ * Connection queries an IBC connection end.
+ * @name getConnection
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.Connection
+ */
+export const getConnection = buildQuery({
     encode: QueryConnectionRequest.encode,
     decode: QueryConnectionResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "Connection",
-    clientResolver,
     deps: [QueryConnectionRequest, QueryConnectionResponse]
 });
-export const createGetConnections = (clientResolver) => buildQuery({
+/**
+ * Connections queries all the IBC connections of a chain.
+ * @name getConnections
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.Connections
+ */
+export const getConnections = buildQuery({
     encode: QueryConnectionsRequest.encode,
     decode: QueryConnectionsResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "Connections",
-    clientResolver,
     deps: [QueryConnectionsRequest, QueryConnectionsResponse]
 });
-export const createGetClientConnections = (clientResolver) => buildQuery({
+/**
+ * ClientConnections queries the connection paths associated with a client
+ * state.
+ * @name getClientConnections
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.ClientConnections
+ */
+export const getClientConnections = buildQuery({
     encode: QueryClientConnectionsRequest.encode,
     decode: QueryClientConnectionsResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "ClientConnections",
-    clientResolver,
     deps: [QueryClientConnectionsRequest, QueryClientConnectionsResponse]
 });
-export const createGetConnectionClientState = (clientResolver) => buildQuery({
+/**
+ * ConnectionClientState queries the client state associated with the
+ * connection.
+ * @name getConnectionClientState
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.ConnectionClientState
+ */
+export const getConnectionClientState = buildQuery({
     encode: QueryConnectionClientStateRequest.encode,
     decode: QueryConnectionClientStateResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "ConnectionClientState",
-    clientResolver,
     deps: [QueryConnectionClientStateRequest, QueryConnectionClientStateResponse]
 });
-export const createGetConnectionConsensusState = (clientResolver) => buildQuery({
+/**
+ * ConnectionConsensusState queries the consensus state associated with the
+ * connection.
+ * @name getConnectionConsensusState
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.ConnectionConsensusState
+ */
+export const getConnectionConsensusState = buildQuery({
     encode: QueryConnectionConsensusStateRequest.encode,
     decode: QueryConnectionConsensusStateResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "ConnectionConsensusState",
-    clientResolver,
     deps: [QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse]
 });
-export const createGetConnectionParams = (clientResolver) => buildQuery({
+/**
+ * ConnectionParams queries all parameters of the ibc connection submodule.
+ * @name getConnectionParams
+ * @package ibc.core.connection.v1
+ * @see proto service: ibc.core.connection.v1.ConnectionParams
+ */
+export const getConnectionParams = buildQuery({
     encode: QueryConnectionParamsRequest.encode,
     decode: QueryConnectionParamsResponse.decode,
     service: "ibc.core.connection.v1.Query",
     method: "ConnectionParams",
-    clientResolver,
     deps: [QueryConnectionParamsRequest, QueryConnectionParamsResponse]
 });