npm - juno-network - Versions diffs - 0.6.0 → 0.8.0 - Mend

juno-network 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1039) hide show

package/module/codegen/cosmos/base/reflection/v2alpha1/reflection.js CHANGED Viewed

@@ -1,5 +1,4 @@
 import * as _m0 from "protobufjs/minimal";
 function createBaseAppDescriptor() {
   return {
     authn: undefined,
@@ -10,78 +9,60 @@ function createBaseAppDescriptor() {
     tx: undefined
   };
 }
 export const AppDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.authn !== undefined) {
       AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).ldelim();
     }
     if (message.chain !== undefined) {
       ChainDescriptor.encode(message.chain, writer.uint32(18).fork()).ldelim();
     }
     if (message.codec !== undefined) {
       CodecDescriptor.encode(message.codec, writer.uint32(26).fork()).ldelim();
     }
     if (message.configuration !== undefined) {
       ConfigurationDescriptor.encode(message.configuration, writer.uint32(34).fork()).ldelim();
     }
     if (message.queryServices !== undefined) {
       QueryServicesDescriptor.encode(message.queryServices, writer.uint32(42).fork()).ldelim();
     }
     if (message.tx !== undefined) {
       TxDescriptor.encode(message.tx, writer.uint32(50).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseAppDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.authn = AuthnDescriptor.decode(reader, reader.uint32());
           break;
         case 2:
           message.chain = ChainDescriptor.decode(reader, reader.uint32());
           break;
         case 3:
           message.codec = CodecDescriptor.decode(reader, reader.uint32());
           break;
         case 4:
           message.configuration = ConfigurationDescriptor.decode(reader, reader.uint32());
           break;
         case 5:
           message.queryServices = QueryServicesDescriptor.decode(reader, reader.uint32());
           break;
         case 6:
           message.tx = TxDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseAppDescriptor();
     message.authn = object.authn !== undefined && object.authn !== null ? AuthnDescriptor.fromPartial(object.authn) : undefined;
@@ -92,113 +73,87 @@ export const AppDescriptor = {
     message.tx = object.tx !== undefined && object.tx !== null ? TxDescriptor.fromPartial(object.tx) : undefined;
     return message;
   }
 };
 function createBaseTxDescriptor() {
   return {
     fullname: "",
     msgs: []
   };
 }
 export const TxDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.fullname !== "") {
       writer.uint32(10).string(message.fullname);
     }
     for (const v of message.msgs) {
       MsgDescriptor.encode(v, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTxDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.fullname = reader.string();
           break;
         case 2:
           message.msgs.push(MsgDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$fullname, _object$msgs;
     const message = createBaseTxDescriptor();
     message.fullname = (_object$fullname = object.fullname) !== null && _object$fullname !== void 0 ? _object$fullname : "";
     message.msgs = ((_object$msgs = object.msgs) === null || _object$msgs === void 0 ? void 0 : _object$msgs.map(e => MsgDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseAuthnDescriptor() {
   return {
     signModes: []
   };
 }
 export const AuthnDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.signModes) {
       SigningModeDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseAuthnDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.signModes.push(SigningModeDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$signModes;
     const message = createBaseAuthnDescriptor();
     message.signModes = ((_object$signModes = object.signModes) === null || _object$signModes === void 0 ? void 0 : _object$signModes.map(e => SigningModeDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseSigningModeDescriptor() {
   return {
     name: "",
@@ -206,160 +161,123 @@ function createBaseSigningModeDescriptor() {
     authnInfoProviderMethodFullname: ""
   };
 }
 export const SigningModeDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.name !== "") {
       writer.uint32(10).string(message.name);
     }
     if (message.number !== 0) {
       writer.uint32(16).int32(message.number);
     }
     if (message.authnInfoProviderMethodFullname !== "") {
       writer.uint32(26).string(message.authnInfoProviderMethodFullname);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSigningModeDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.name = reader.string();
           break;
         case 2:
           message.number = reader.int32();
           break;
         case 3:
           message.authnInfoProviderMethodFullname = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$name, _object$number, _object$authnInfoProv;
     const message = createBaseSigningModeDescriptor();
     message.name = (_object$name = object.name) !== null && _object$name !== void 0 ? _object$name : "";
     message.number = (_object$number = object.number) !== null && _object$number !== void 0 ? _object$number : 0;
     message.authnInfoProviderMethodFullname = (_object$authnInfoProv = object.authnInfoProviderMethodFullname) !== null && _object$authnInfoProv !== void 0 ? _object$authnInfoProv : "";
     return message;
   }
 };
 function createBaseChainDescriptor() {
   return {
     id: ""
   };
 }
 export const ChainDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.id !== "") {
       writer.uint32(10).string(message.id);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseChainDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.id = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$id;
     const message = createBaseChainDescriptor();
     message.id = (_object$id = object.id) !== null && _object$id !== void 0 ? _object$id : "";
     return message;
   }
 };
 function createBaseCodecDescriptor() {
   return {
     interfaces: []
   };
 }
 export const CodecDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.interfaces) {
       InterfaceDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCodecDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.interfaces.push(InterfaceDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$interfaces;
     const message = createBaseCodecDescriptor();
     message.interfaces = ((_object$interfaces = object.interfaces) === null || _object$interfaces === void 0 ? void 0 : _object$interfaces.map(e => InterfaceDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseInterfaceDescriptor() {
   return {
     fullname: "",
@@ -367,795 +285,613 @@ function createBaseInterfaceDescriptor() {
     interfaceImplementers: []
   };
 }
 export const InterfaceDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.fullname !== "") {
       writer.uint32(10).string(message.fullname);
     }
     for (const v of message.interfaceAcceptingMessages) {
       InterfaceAcceptingMessageDescriptor.encode(v, writer.uint32(18).fork()).ldelim();
     }
     for (const v of message.interfaceImplementers) {
       InterfaceImplementerDescriptor.encode(v, writer.uint32(26).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInterfaceDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.fullname = reader.string();
           break;
         case 2:
           message.interfaceAcceptingMessages.push(InterfaceAcceptingMessageDescriptor.decode(reader, reader.uint32()));
           break;
         case 3:
           message.interfaceImplementers.push(InterfaceImplementerDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$fullname2, _object$interfaceAcce, _object$interfaceImpl;
     const message = createBaseInterfaceDescriptor();
     message.fullname = (_object$fullname2 = object.fullname) !== null && _object$fullname2 !== void 0 ? _object$fullname2 : "";
     message.interfaceAcceptingMessages = ((_object$interfaceAcce = object.interfaceAcceptingMessages) === null || _object$interfaceAcce === void 0 ? void 0 : _object$interfaceAcce.map(e => InterfaceAcceptingMessageDescriptor.fromPartial(e))) || [];
     message.interfaceImplementers = ((_object$interfaceImpl = object.interfaceImplementers) === null || _object$interfaceImpl === void 0 ? void 0 : _object$interfaceImpl.map(e => InterfaceImplementerDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseInterfaceImplementerDescriptor() {
   return {
     fullname: "",
     typeUrl: ""
   };
 }
 export const InterfaceImplementerDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.fullname !== "") {
       writer.uint32(10).string(message.fullname);
     }
     if (message.typeUrl !== "") {
       writer.uint32(18).string(message.typeUrl);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInterfaceImplementerDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.fullname = reader.string();
           break;
         case 2:
           message.typeUrl = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$fullname3, _object$typeUrl;
     const message = createBaseInterfaceImplementerDescriptor();
     message.fullname = (_object$fullname3 = object.fullname) !== null && _object$fullname3 !== void 0 ? _object$fullname3 : "";
     message.typeUrl = (_object$typeUrl = object.typeUrl) !== null && _object$typeUrl !== void 0 ? _object$typeUrl : "";
     return message;
   }
 };
 function createBaseInterfaceAcceptingMessageDescriptor() {
   return {
     fullname: "",
     fieldDescriptorNames: []
   };
 }
 export const InterfaceAcceptingMessageDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.fullname !== "") {
       writer.uint32(10).string(message.fullname);
     }
     for (const v of message.fieldDescriptorNames) {
       writer.uint32(18).string(v);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInterfaceAcceptingMessageDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.fullname = reader.string();
           break;
         case 2:
           message.fieldDescriptorNames.push(reader.string());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$fullname4, _object$fieldDescript;
     const message = createBaseInterfaceAcceptingMessageDescriptor();
     message.fullname = (_object$fullname4 = object.fullname) !== null && _object$fullname4 !== void 0 ? _object$fullname4 : "";
     message.fieldDescriptorNames = ((_object$fieldDescript = object.fieldDescriptorNames) === null || _object$fieldDescript === void 0 ? void 0 : _object$fieldDescript.map(e => e)) || [];
     return message;
   }
 };
 function createBaseConfigurationDescriptor() {
   return {
     bech32AccountAddressPrefix: ""
   };
 }
 export const ConfigurationDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.bech32AccountAddressPrefix !== "") {
       writer.uint32(10).string(message.bech32AccountAddressPrefix);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseConfigurationDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.bech32AccountAddressPrefix = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$bech32Account;
     const message = createBaseConfigurationDescriptor();
     message.bech32AccountAddressPrefix = (_object$bech32Account = object.bech32AccountAddressPrefix) !== null && _object$bech32Account !== void 0 ? _object$bech32Account : "";
     return message;
   }
 };
 function createBaseMsgDescriptor() {
   return {
     msgTypeUrl: ""
   };
 }
 export const MsgDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.msgTypeUrl !== "") {
       writer.uint32(10).string(message.msgTypeUrl);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseMsgDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.msgTypeUrl = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$msgTypeUrl;
     const message = createBaseMsgDescriptor();
     message.msgTypeUrl = (_object$msgTypeUrl = object.msgTypeUrl) !== null && _object$msgTypeUrl !== void 0 ? _object$msgTypeUrl : "";
     return message;
   }
 };
 function createBaseGetAuthnDescriptorRequest() {
   return {};
 }
 export const GetAuthnDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetAuthnDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetAuthnDescriptorRequest();
     return message;
   }
 };
 function createBaseGetAuthnDescriptorResponse() {
   return {
     authn: undefined
   };
 }
 export const GetAuthnDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.authn !== undefined) {
       AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetAuthnDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.authn = AuthnDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetAuthnDescriptorResponse();
     message.authn = object.authn !== undefined && object.authn !== null ? AuthnDescriptor.fromPartial(object.authn) : undefined;
     return message;
   }
 };
 function createBaseGetChainDescriptorRequest() {
   return {};
 }
 export const GetChainDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetChainDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetChainDescriptorRequest();
     return message;
   }
 };
 function createBaseGetChainDescriptorResponse() {
   return {
     chain: undefined
   };
 }
 export const GetChainDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.chain !== undefined) {
       ChainDescriptor.encode(message.chain, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetChainDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.chain = ChainDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetChainDescriptorResponse();
     message.chain = object.chain !== undefined && object.chain !== null ? ChainDescriptor.fromPartial(object.chain) : undefined;
     return message;
   }
 };
 function createBaseGetCodecDescriptorRequest() {
   return {};
 }
 export const GetCodecDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetCodecDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetCodecDescriptorRequest();
     return message;
   }
 };
 function createBaseGetCodecDescriptorResponse() {
   return {
     codec: undefined
   };
 }
 export const GetCodecDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.codec !== undefined) {
       CodecDescriptor.encode(message.codec, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetCodecDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.codec = CodecDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetCodecDescriptorResponse();
     message.codec = object.codec !== undefined && object.codec !== null ? CodecDescriptor.fromPartial(object.codec) : undefined;
     return message;
   }
 };
 function createBaseGetConfigurationDescriptorRequest() {
   return {};
 }
 export const GetConfigurationDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetConfigurationDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetConfigurationDescriptorRequest();
     return message;
   }
 };
 function createBaseGetConfigurationDescriptorResponse() {
   return {
     config: undefined
   };
 }
 export const GetConfigurationDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.config !== undefined) {
       ConfigurationDescriptor.encode(message.config, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetConfigurationDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.config = ConfigurationDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetConfigurationDescriptorResponse();
     message.config = object.config !== undefined && object.config !== null ? ConfigurationDescriptor.fromPartial(object.config) : undefined;
     return message;
   }
 };
 function createBaseGetQueryServicesDescriptorRequest() {
   return {};
 }
 export const GetQueryServicesDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetQueryServicesDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetQueryServicesDescriptorRequest();
     return message;
   }
 };
 function createBaseGetQueryServicesDescriptorResponse() {
   return {
     queries: undefined
   };
 }
 export const GetQueryServicesDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.queries !== undefined) {
       QueryServicesDescriptor.encode(message.queries, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetQueryServicesDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.queries = QueryServicesDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetQueryServicesDescriptorResponse();
     message.queries = object.queries !== undefined && object.queries !== null ? QueryServicesDescriptor.fromPartial(object.queries) : undefined;
     return message;
   }
 };
 function createBaseGetTxDescriptorRequest() {
   return {};
 }
 export const GetTxDescriptorRequest = {
   encode(_, writer = _m0.Writer.create()) {
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetTxDescriptorRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(_) {
     const message = createBaseGetTxDescriptorRequest();
     return message;
   }
 };
 function createBaseGetTxDescriptorResponse() {
   return {
     tx: undefined
   };
 }
 export const GetTxDescriptorResponse = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.tx !== undefined) {
       TxDescriptor.encode(message.tx, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetTxDescriptorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.tx = TxDescriptor.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     const message = createBaseGetTxDescriptorResponse();
     message.tx = object.tx !== undefined && object.tx !== null ? TxDescriptor.fromPartial(object.tx) : undefined;
     return message;
   }
 };
 function createBaseQueryServicesDescriptor() {
   return {
     queryServices: []
   };
 }
 export const QueryServicesDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     for (const v of message.queryServices) {
       QueryServiceDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseQueryServicesDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.queryServices.push(QueryServiceDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$queryServices;
     const message = createBaseQueryServicesDescriptor();
     message.queryServices = ((_object$queryServices = object.queryServices) === null || _object$queryServices === void 0 ? void 0 : _object$queryServices.map(e => QueryServiceDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseQueryServiceDescriptor() {
   return {
     fullname: "",
@@ -1163,119 +899,92 @@ function createBaseQueryServiceDescriptor() {
     methods: []
   };
 }
 export const QueryServiceDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.fullname !== "") {
       writer.uint32(10).string(message.fullname);
     }
     if (message.isModule === true) {
       writer.uint32(16).bool(message.isModule);
     }
     for (const v of message.methods) {
       QueryMethodDescriptor.encode(v, writer.uint32(26).fork()).ldelim();
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseQueryServiceDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.fullname = reader.string();
           break;
         case 2:
           message.isModule = reader.bool();
           break;
         case 3:
           message.methods.push(QueryMethodDescriptor.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$fullname5, _object$isModule, _object$methods;
     const message = createBaseQueryServiceDescriptor();
     message.fullname = (_object$fullname5 = object.fullname) !== null && _object$fullname5 !== void 0 ? _object$fullname5 : "";
     message.isModule = (_object$isModule = object.isModule) !== null && _object$isModule !== void 0 ? _object$isModule : false;
     message.methods = ((_object$methods = object.methods) === null || _object$methods === void 0 ? void 0 : _object$methods.map(e => QueryMethodDescriptor.fromPartial(e))) || [];
     return message;
   }
 };
 function createBaseQueryMethodDescriptor() {
   return {
     name: "",
     fullQueryPath: ""
   };
 }
 export const QueryMethodDescriptor = {
   encode(message, writer = _m0.Writer.create()) {
     if (message.name !== "") {
       writer.uint32(10).string(message.name);
     }
     if (message.fullQueryPath !== "") {
       writer.uint32(18).string(message.fullQueryPath);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseQueryMethodDescriptor();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
           message.name = reader.string();
           break;
         case 2:
           message.fullQueryPath = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
     return message;
   },
   fromPartial(object) {
     var _object$name2, _object$fullQueryPath;
     const message = createBaseQueryMethodDescriptor();
     message.name = (_object$name2 = object.name) !== null && _object$name2 !== void 0 ? _object$name2 : "";
     message.fullQueryPath = (_object$fullQueryPath = object.fullQueryPath) !== null && _object$fullQueryPath !== void 0 ? _object$fullQueryPath : "";
     return message;
   }
 };