@xpla/xpla-react 1.7.0 → 1.8.0-rc.0

package/esm/ibc/applications/transfer/v1/query.js

@@ -1,37 +1,37 @@
 import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination";
-import { DenomTrace, Params } from "./transfer";
+import { Params } from "./transfer";
+import { Denom } from "./token";
 import { Coin } from "../../../../cosmos/base/v1beta1/coin";
 import { BinaryReader, BinaryWriter } from "../../../../binary";
-function createBaseQueryDenomTraceRequest() {
-    return {
-        hash: ""
-    };
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBaseQueryParamsRequest() {
+    return {};
 }
-export const QueryDenomTraceRequest = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceRequest",
-    aminoType: "cosmos-sdk/QueryDenomTraceRequest",
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest",
+    aminoType: "cosmos-sdk/QueryParamsRequest",
     is(o) {
-        return o && (o.$typeUrl === QueryDenomTraceRequest.typeUrl || typeof o.hash === "string");
+        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
     },
     isAmino(o) {
-        return o && (o.$typeUrl === QueryDenomTraceRequest.typeUrl || typeof o.hash === "string");
+        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
     },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.hash !== "") {
-            writer.uint32(10).string(message.hash);
-        }
+    encode(_, writer = BinaryWriter.create()) {
         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 = createBaseQueryDenomTraceRequest();
+        const message = createBaseQueryParamsRequest();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
-                case 1:
-                    message.hash = reader.string();
-                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -39,75 +39,76 @@ export const QueryDenomTraceRequest = {
         }
         return message;
     },
-    fromPartial(object) {
-        const message = createBaseQueryDenomTraceRequest();
-        message.hash = object.hash ?? "";
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
         return message;
     },
-    fromAmino(object) {
-        const message = createBaseQueryDenomTraceRequest();
-        if (object.hash !== undefined && object.hash !== null) {
-            message.hash = object.hash;
-        }
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
         return message;
     },
-    toAmino(message) {
+    toAmino(_) {
         const obj = {};
-        obj.hash = message.hash === "" ? undefined : message.hash;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryDenomTraceRequest.fromAmino(object.value);
+        return QueryParamsRequest.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryDenomTraceRequest",
-            value: QueryDenomTraceRequest.toAmino(message)
+            type: "cosmos-sdk/QueryParamsRequest",
+            value: QueryParamsRequest.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryDenomTraceRequest.decode(message.value);
+        return QueryParamsRequest.decode(message.value);
     },
     toProto(message) {
-        return QueryDenomTraceRequest.encode(message).finish();
+        return QueryParamsRequest.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceRequest",
-            value: QueryDenomTraceRequest.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
         };
     },
     registerTypeUrl() { }
 };
-function createBaseQueryDenomTraceResponse() {
+function createBaseQueryParamsResponse() {
     return {
-        denomTrace: undefined
+        params: undefined
     };
 }
-export const QueryDenomTraceResponse = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceResponse",
-    aminoType: "cosmos-sdk/QueryDenomTraceResponse",
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse",
+    aminoType: "cosmos-sdk/QueryParamsResponse",
     is(o) {
-        return o && o.$typeUrl === QueryDenomTraceResponse.typeUrl;
+        return o && o.$typeUrl === QueryParamsResponse.typeUrl;
     },
     isAmino(o) {
-        return o && o.$typeUrl === QueryDenomTraceResponse.typeUrl;
+        return o && o.$typeUrl === QueryParamsResponse.typeUrl;
     },
     encode(message, writer = BinaryWriter.create()) {
-        if (message.denomTrace !== undefined) {
-            DenomTrace.encode(message.denomTrace, writer.uint32(10).fork()).ldelim();
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
         }
         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 = createBaseQueryDenomTraceResponse();
+        const message = createBaseQueryParamsResponse();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.denomTrace = DenomTrace.decode(reader, reader.uint32());
+                    message.params = Params.decode(reader, reader.uint32());
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -117,76 +118,86 @@ export const QueryDenomTraceResponse = {
         return message;
     },
     fromPartial(object) {
-        const message = createBaseQueryDenomTraceResponse();
-        message.denomTrace = object.denomTrace !== undefined && object.denomTrace !== null ? DenomTrace.fromPartial(object.denomTrace) : undefined;
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
         return message;
     },
     fromAmino(object) {
-        const message = createBaseQueryDenomTraceResponse();
-        if (object.denom_trace !== undefined && object.denom_trace !== null) {
-            message.denomTrace = DenomTrace.fromAmino(object.denom_trace);
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
         }
         return message;
     },
     toAmino(message) {
         const obj = {};
-        obj.denom_trace = message.denomTrace ? DenomTrace.toAmino(message.denomTrace) : undefined;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryDenomTraceResponse.fromAmino(object.value);
+        return QueryParamsResponse.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryDenomTraceResponse",
-            value: QueryDenomTraceResponse.toAmino(message)
+            type: "cosmos-sdk/QueryParamsResponse",
+            value: QueryParamsResponse.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryDenomTraceResponse.decode(message.value);
+        return QueryParamsResponse.decode(message.value);
     },
     toProto(message) {
-        return QueryDenomTraceResponse.encode(message).finish();
+        return QueryParamsResponse.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceResponse",
-            value: QueryDenomTraceResponse.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
         };
     },
     registerTypeUrl() {
-        DenomTrace.registerTypeUrl();
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryParamsResponse.typeUrl)) {
+            return;
+        }
+        Params.registerTypeUrl();
     }
 };
-function createBaseQueryDenomTracesRequest() {
+function createBaseQueryDenomRequest() {
     return {
-        pagination: undefined
+        hash: ""
     };
 }
-export const QueryDenomTracesRequest = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesRequest",
-    aminoType: "cosmos-sdk/QueryDenomTracesRequest",
+/**
+ * QueryDenomRequest is the request type for the Query/Denom RPC
+ * method
+ * @name QueryDenomRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomRequest
+ */
+export const QueryDenomRequest = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryDenomRequest",
+    aminoType: "cosmos-sdk/QueryDenomRequest",
     is(o) {
-        return o && o.$typeUrl === QueryDenomTracesRequest.typeUrl;
+        return o && (o.$typeUrl === QueryDenomRequest.typeUrl || typeof o.hash === "string");
     },
     isAmino(o) {
-        return o && o.$typeUrl === QueryDenomTracesRequest.typeUrl;
+        return o && (o.$typeUrl === QueryDenomRequest.typeUrl || typeof o.hash === "string");
     },
     encode(message, writer = BinaryWriter.create()) {
-        if (message.pagination !== undefined) {
-            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        if (message.hash !== "") {
+            writer.uint32(10).string(message.hash);
         }
         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 = createBaseQueryDenomTracesRequest();
+        const message = createBaseQueryDenomRequest();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    message.hash = reader.string();
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -196,83 +207,81 @@ export const QueryDenomTracesRequest = {
         return message;
     },
     fromPartial(object) {
-        const message = createBaseQueryDenomTracesRequest();
-        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        const message = createBaseQueryDenomRequest();
+        message.hash = object.hash ?? "";
         return message;
     },
     fromAmino(object) {
-        const message = createBaseQueryDenomTracesRequest();
-        if (object.pagination !== undefined && object.pagination !== null) {
-            message.pagination = PageRequest.fromAmino(object.pagination);
+        const message = createBaseQueryDenomRequest();
+        if (object.hash !== undefined && object.hash !== null) {
+            message.hash = object.hash;
         }
         return message;
     },
     toAmino(message) {
         const obj = {};
-        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        obj.hash = message.hash === "" ? undefined : message.hash;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryDenomTracesRequest.fromAmino(object.value);
+        return QueryDenomRequest.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryDenomTracesRequest",
-            value: QueryDenomTracesRequest.toAmino(message)
+            type: "cosmos-sdk/QueryDenomRequest",
+            value: QueryDenomRequest.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryDenomTracesRequest.decode(message.value);
+        return QueryDenomRequest.decode(message.value);
     },
     toProto(message) {
-        return QueryDenomTracesRequest.encode(message).finish();
+        return QueryDenomRequest.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesRequest",
-            value: QueryDenomTracesRequest.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryDenomRequest",
+            value: QueryDenomRequest.encode(message).finish()
         };
     },
-    registerTypeUrl() {
-        PageRequest.registerTypeUrl();
-    }
+    registerTypeUrl() { }
 };
-function createBaseQueryDenomTracesResponse() {
+function createBaseQueryDenomResponse() {
     return {
-        denomTraces: [],
-        pagination: undefined
+        denom: undefined
     };
 }
-export const QueryDenomTracesResponse = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesResponse",
-    aminoType: "cosmos-sdk/QueryDenomTracesResponse",
+/**
+ * QueryDenomResponse is the response type for the Query/Denom RPC
+ * method.
+ * @name QueryDenomResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomResponse
+ */
+export const QueryDenomResponse = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryDenomResponse",
+    aminoType: "cosmos-sdk/QueryDenomResponse",
     is(o) {
-        return o && (o.$typeUrl === QueryDenomTracesResponse.typeUrl || Array.isArray(o.denomTraces) && (!o.denomTraces.length || DenomTrace.is(o.denomTraces[0])));
+        return o && o.$typeUrl === QueryDenomResponse.typeUrl;
     },
     isAmino(o) {
-        return o && (o.$typeUrl === QueryDenomTracesResponse.typeUrl || Array.isArray(o.denom_traces) && (!o.denom_traces.length || DenomTrace.isAmino(o.denom_traces[0])));
+        return o && o.$typeUrl === QueryDenomResponse.typeUrl;
     },
     encode(message, writer = BinaryWriter.create()) {
-        for (const v of message.denomTraces) {
-            DenomTrace.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.pagination !== undefined) {
-            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        if (message.denom !== undefined) {
+            Denom.encode(message.denom, writer.uint32(10).fork()).ldelim();
         }
         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 = createBaseQueryDenomTracesResponse();
+        const message = createBaseQueryDenomResponse();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.denomTraces.push(DenomTrace.decode(reader, reader.uint32()));
-                    break;
-                case 2:
-                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    message.denom = Denom.decode(reader, reader.uint32());
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -282,78 +291,87 @@ export const QueryDenomTracesResponse = {
         return message;
     },
     fromPartial(object) {
-        const message = createBaseQueryDenomTracesResponse();
-        message.denomTraces = object.denomTraces?.map(e => DenomTrace.fromPartial(e)) || [];
-        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        const message = createBaseQueryDenomResponse();
+        message.denom = object.denom !== undefined && object.denom !== null ? Denom.fromPartial(object.denom) : undefined;
         return message;
     },
     fromAmino(object) {
-        const message = createBaseQueryDenomTracesResponse();
-        message.denomTraces = object.denom_traces?.map(e => DenomTrace.fromAmino(e)) || [];
-        if (object.pagination !== undefined && object.pagination !== null) {
-            message.pagination = PageResponse.fromAmino(object.pagination);
+        const message = createBaseQueryDenomResponse();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = Denom.fromAmino(object.denom);
         }
         return message;
     },
     toAmino(message) {
         const obj = {};
-        if (message.denomTraces) {
-            obj.denom_traces = message.denomTraces.map(e => e ? DenomTrace.toAmino(e) : undefined);
-        }
-        else {
-            obj.denom_traces = message.denomTraces;
-        }
-        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        obj.denom = message.denom ? Denom.toAmino(message.denom) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryDenomTracesResponse.fromAmino(object.value);
+        return QueryDenomResponse.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryDenomTracesResponse",
-            value: QueryDenomTracesResponse.toAmino(message)
+            type: "cosmos-sdk/QueryDenomResponse",
+            value: QueryDenomResponse.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryDenomTracesResponse.decode(message.value);
+        return QueryDenomResponse.decode(message.value);
     },
     toProto(message) {
-        return QueryDenomTracesResponse.encode(message).finish();
+        return QueryDenomResponse.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesResponse",
-            value: QueryDenomTracesResponse.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryDenomResponse",
+            value: QueryDenomResponse.encode(message).finish()
         };
     },
     registerTypeUrl() {
-        DenomTrace.registerTypeUrl();
-        PageResponse.registerTypeUrl();
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryDenomResponse.typeUrl)) {
+            return;
+        }
+        Denom.registerTypeUrl();
     }
 };
-function createBaseQueryParamsRequest() {
-    return {};
+function createBaseQueryDenomsRequest() {
+    return {
+        pagination: undefined
+    };
 }
-export const QueryParamsRequest = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest",
-    aminoType: "cosmos-sdk/QueryParamsRequest",
+/**
+ * QueryDenomsRequest is the request type for the Query/Denoms RPC
+ * method
+ * @name QueryDenomsRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomsRequest
+ */
+export const QueryDenomsRequest = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryDenomsRequest",
+    aminoType: "cosmos-sdk/QueryDenomsRequest",
     is(o) {
-        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+        return o && o.$typeUrl === QueryDenomsRequest.typeUrl;
     },
     isAmino(o) {
-        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+        return o && o.$typeUrl === QueryDenomsRequest.typeUrl;
     },
-    encode(_, writer = BinaryWriter.create()) {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
         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 = createBaseQueryParamsRequest();
+        const message = createBaseQueryDenomsRequest();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -361,70 +379,94 @@ export const QueryParamsRequest = {
         }
         return message;
     },
-    fromPartial(_) {
-        const message = createBaseQueryParamsRequest();
+    fromPartial(object) {
+        const message = createBaseQueryDenomsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
         return message;
     },
-    fromAmino(_) {
-        const message = createBaseQueryParamsRequest();
+    fromAmino(object) {
+        const message = createBaseQueryDenomsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
         return message;
     },
-    toAmino(_) {
+    toAmino(message) {
         const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryParamsRequest.fromAmino(object.value);
+        return QueryDenomsRequest.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryParamsRequest",
-            value: QueryParamsRequest.toAmino(message)
+            type: "cosmos-sdk/QueryDenomsRequest",
+            value: QueryDenomsRequest.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryParamsRequest.decode(message.value);
+        return QueryDenomsRequest.decode(message.value);
     },
     toProto(message) {
-        return QueryParamsRequest.encode(message).finish();
+        return QueryDenomsRequest.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest",
-            value: QueryParamsRequest.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryDenomsRequest",
+            value: QueryDenomsRequest.encode(message).finish()
         };
     },
-    registerTypeUrl() { }
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryDenomsRequest.typeUrl)) {
+            return;
+        }
+        PageRequest.registerTypeUrl();
+    }
 };
-function createBaseQueryParamsResponse() {
+function createBaseQueryDenomsResponse() {
     return {
-        params: undefined
+        denoms: [],
+        pagination: undefined
     };
 }
-export const QueryParamsResponse = {
-    typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse",
-    aminoType: "cosmos-sdk/QueryParamsResponse",
+/**
+ * QueryDenomsResponse is the response type for the Query/Denoms RPC
+ * method.
+ * @name QueryDenomsResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomsResponse
+ */
+export const QueryDenomsResponse = {
+    typeUrl: "/ibc.applications.transfer.v1.QueryDenomsResponse",
+    aminoType: "cosmos-sdk/QueryDenomsResponse",
     is(o) {
-        return o && o.$typeUrl === QueryParamsResponse.typeUrl;
+        return o && (o.$typeUrl === QueryDenomsResponse.typeUrl || Array.isArray(o.denoms) && (!o.denoms.length || Denom.is(o.denoms[0])));
     },
     isAmino(o) {
-        return o && o.$typeUrl === QueryParamsResponse.typeUrl;
+        return o && (o.$typeUrl === QueryDenomsResponse.typeUrl || Array.isArray(o.denoms) && (!o.denoms.length || Denom.isAmino(o.denoms[0])));
     },
     encode(message, writer = BinaryWriter.create()) {
-        if (message.params !== undefined) {
-            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        for (const v of message.denoms) {
+            Denom.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
         }
         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 = createBaseQueryParamsResponse();
+        const message = createBaseQueryDenomsResponse();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.params = Params.decode(reader, reader.uint32());
+                    message.denoms.push(Denom.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
                     break;
                 default:
                     reader.skipType(tag & 7);
@@ -434,45 +476,57 @@ export const QueryParamsResponse = {
         return message;
     },
     fromPartial(object) {
-        const message = createBaseQueryParamsResponse();
-        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        const message = createBaseQueryDenomsResponse();
+        message.denoms = object.denoms?.map(e => Denom.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
         return message;
     },
     fromAmino(object) {
-        const message = createBaseQueryParamsResponse();
-        if (object.params !== undefined && object.params !== null) {
-            message.params = Params.fromAmino(object.params);
+        const message = createBaseQueryDenomsResponse();
+        message.denoms = object.denoms?.map(e => Denom.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
         }
         return message;
     },
     toAmino(message) {
         const obj = {};
-        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        if (message.denoms) {
+            obj.denoms = message.denoms.map(e => e ? Denom.toAmino(e) : undefined);
+        }
+        else {
+            obj.denoms = message.denoms;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
         return obj;
     },
     fromAminoMsg(object) {
-        return QueryParamsResponse.fromAmino(object.value);
+        return QueryDenomsResponse.fromAmino(object.value);
     },
     toAminoMsg(message) {
         return {
-            type: "cosmos-sdk/QueryParamsResponse",
-            value: QueryParamsResponse.toAmino(message)
+            type: "cosmos-sdk/QueryDenomsResponse",
+            value: QueryDenomsResponse.toAmino(message)
         };
     },
     fromProtoMsg(message) {
-        return QueryParamsResponse.decode(message.value);
+        return QueryDenomsResponse.decode(message.value);
     },
     toProto(message) {
-        return QueryParamsResponse.encode(message).finish();
+        return QueryDenomsResponse.encode(message).finish();
     },
     toProtoMsg(message) {
         return {
-            typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse",
-            value: QueryParamsResponse.encode(message).finish()
+            typeUrl: "/ibc.applications.transfer.v1.QueryDenomsResponse",
+            value: QueryDenomsResponse.encode(message).finish()
         };
     },
     registerTypeUrl() {
-        Params.registerTypeUrl();
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryDenomsResponse.typeUrl)) {
+            return;
+        }
+        Denom.registerTypeUrl();
+        PageResponse.registerTypeUrl();
     }
 };
 function createBaseQueryDenomHashRequest() {
@@ -480,6 +534,13 @@ function createBaseQueryDenomHashRequest() {
         trace: ""
     };
 }
+/**
+ * QueryDenomHashRequest is the request type for the Query/DenomHash RPC
+ * method
+ * @name QueryDenomHashRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomHashRequest
+ */
 export const QueryDenomHashRequest = {
     typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashRequest",
     aminoType: "cosmos-sdk/QueryDenomHashRequest",
@@ -557,6 +618,13 @@ function createBaseQueryDenomHashResponse() {
         hash: ""
     };
 }
+/**
+ * QueryDenomHashResponse is the response type for the Query/DenomHash RPC
+ * method.
+ * @name QueryDenomHashResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryDenomHashResponse
+ */
 export const QueryDenomHashResponse = {
     typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashResponse",
     aminoType: "cosmos-sdk/QueryDenomHashResponse",
@@ -635,6 +703,12 @@ function createBaseQueryEscrowAddressRequest() {
         channelId: ""
     };
 }
+/**
+ * QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method.
+ * @name QueryEscrowAddressRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryEscrowAddressRequest
+ */
 export const QueryEscrowAddressRequest = {
     typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressRequest",
     aminoType: "cosmos-sdk/QueryEscrowAddressRequest",
@@ -723,6 +797,12 @@ function createBaseQueryEscrowAddressResponse() {
         escrowAddress: ""
     };
 }
+/**
+ * QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method.
+ * @name QueryEscrowAddressResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryEscrowAddressResponse
+ */
 export const QueryEscrowAddressResponse = {
     typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressResponse",
     aminoType: "cosmos-sdk/QueryEscrowAddressResponse",
@@ -800,6 +880,12 @@ function createBaseQueryTotalEscrowForDenomRequest() {
         denom: ""
     };
 }
+/**
+ * QueryTotalEscrowForDenomRequest is the request type for TotalEscrowForDenom RPC method.
+ * @name QueryTotalEscrowForDenomRequest
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest
+ */
 export const QueryTotalEscrowForDenomRequest = {
     typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest",
     aminoType: "cosmos-sdk/QueryTotalEscrowForDenomRequest",
@@ -877,6 +963,12 @@ function createBaseQueryTotalEscrowForDenomResponse() {
         amount: Coin.fromPartial({})
     };
 }
+/**
+ * QueryTotalEscrowForDenomResponse is the response type for TotalEscrowForDenom RPC method.
+ * @name QueryTotalEscrowForDenomResponse
+ * @package ibc.applications.transfer.v1
+ * @see proto type: ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse
+ */
 export const QueryTotalEscrowForDenomResponse = {
     typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse",
     aminoType: "cosmos-sdk/QueryTotalEscrowForDenomResponse",
@@ -948,6 +1040,9 @@ export const QueryTotalEscrowForDenomResponse = {
         };
     },
     registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryTotalEscrowForDenomResponse.typeUrl)) {
+            return;
+        }
         Coin.registerTypeUrl();
     }
 };