interchainjs
Version:
InterchainJS is a JavaScript library for interacting with Cosmos SDK based blockchains.
1,244 lines • 91.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueryMethodDescriptor = exports.QueryServiceDescriptor = exports.QueryServicesDescriptor = exports.GetTxDescriptorResponse = exports.GetTxDescriptorRequest = exports.GetQueryServicesDescriptorResponse = exports.GetQueryServicesDescriptorRequest = exports.GetConfigurationDescriptorResponse = exports.GetConfigurationDescriptorRequest = exports.GetCodecDescriptorResponse = exports.GetCodecDescriptorRequest = exports.GetChainDescriptorResponse = exports.GetChainDescriptorRequest = exports.GetAuthnDescriptorResponse = exports.GetAuthnDescriptorRequest = exports.MsgDescriptor = exports.ConfigurationDescriptor = exports.InterfaceAcceptingMessageDescriptor = exports.InterfaceImplementerDescriptor = exports.InterfaceDescriptor = exports.CodecDescriptor = exports.ChainDescriptor = exports.SigningModeDescriptor = exports.AuthnDescriptor = exports.TxDescriptor = exports.AppDescriptor = void 0;
const binary_1 = require("../../../../binary");
const registry_1 = require("../../../../registry");
function createBaseAppDescriptor() {
return {
authn: undefined,
chain: undefined,
codec: undefined,
configuration: undefined,
queryServices: undefined,
tx: undefined
};
}
/**
* AppDescriptor describes a cosmos-sdk based application
* @name AppDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.AppDescriptor
*/
exports.AppDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.AppDescriptor",
aminoType: "cosmos-sdk/AppDescriptor",
is(o) {
return o && o.$typeUrl === exports.AppDescriptor.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === exports.AppDescriptor.typeUrl;
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.authn !== undefined) {
exports.AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).ldelim();
}
if (message.chain !== undefined) {
exports.ChainDescriptor.encode(message.chain, writer.uint32(18).fork()).ldelim();
}
if (message.codec !== undefined) {
exports.CodecDescriptor.encode(message.codec, writer.uint32(26).fork()).ldelim();
}
if (message.configuration !== undefined) {
exports.ConfigurationDescriptor.encode(message.configuration, writer.uint32(34).fork()).ldelim();
}
if (message.queryServices !== undefined) {
exports.QueryServicesDescriptor.encode(message.queryServices, writer.uint32(42).fork()).ldelim();
}
if (message.tx !== undefined) {
exports.TxDescriptor.encode(message.tx, writer.uint32(50).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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 = exports.AuthnDescriptor.decode(reader, reader.uint32());
break;
case 2:
message.chain = exports.ChainDescriptor.decode(reader, reader.uint32());
break;
case 3:
message.codec = exports.CodecDescriptor.decode(reader, reader.uint32());
break;
case 4:
message.configuration = exports.ConfigurationDescriptor.decode(reader, reader.uint32());
break;
case 5:
message.queryServices = exports.QueryServicesDescriptor.decode(reader, reader.uint32());
break;
case 6:
message.tx = exports.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 ? exports.AuthnDescriptor.fromPartial(object.authn) : undefined;
message.chain = object.chain !== undefined && object.chain !== null ? exports.ChainDescriptor.fromPartial(object.chain) : undefined;
message.codec = object.codec !== undefined && object.codec !== null ? exports.CodecDescriptor.fromPartial(object.codec) : undefined;
message.configuration = object.configuration !== undefined && object.configuration !== null ? exports.ConfigurationDescriptor.fromPartial(object.configuration) : undefined;
message.queryServices = object.queryServices !== undefined && object.queryServices !== null ? exports.QueryServicesDescriptor.fromPartial(object.queryServices) : undefined;
message.tx = object.tx !== undefined && object.tx !== null ? exports.TxDescriptor.fromPartial(object.tx) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseAppDescriptor();
if (object.authn !== undefined && object.authn !== null) {
message.authn = exports.AuthnDescriptor.fromAmino(object.authn);
}
if (object.chain !== undefined && object.chain !== null) {
message.chain = exports.ChainDescriptor.fromAmino(object.chain);
}
if (object.codec !== undefined && object.codec !== null) {
message.codec = exports.CodecDescriptor.fromAmino(object.codec);
}
if (object.configuration !== undefined && object.configuration !== null) {
message.configuration = exports.ConfigurationDescriptor.fromAmino(object.configuration);
}
if (object.query_services !== undefined && object.query_services !== null) {
message.queryServices = exports.QueryServicesDescriptor.fromAmino(object.query_services);
}
if (object.tx !== undefined && object.tx !== null) {
message.tx = exports.TxDescriptor.fromAmino(object.tx);
}
return message;
},
toAmino(message) {
const obj = {};
obj.authn = message.authn ? exports.AuthnDescriptor.toAmino(message.authn) : undefined;
obj.chain = message.chain ? exports.ChainDescriptor.toAmino(message.chain) : undefined;
obj.codec = message.codec ? exports.CodecDescriptor.toAmino(message.codec) : undefined;
obj.configuration = message.configuration ? exports.ConfigurationDescriptor.toAmino(message.configuration) : undefined;
obj.query_services = message.queryServices ? exports.QueryServicesDescriptor.toAmino(message.queryServices) : undefined;
obj.tx = message.tx ? exports.TxDescriptor.toAmino(message.tx) : undefined;
return obj;
},
fromAminoMsg(object) {
return exports.AppDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/AppDescriptor",
value: exports.AppDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.AppDescriptor.decode(message.value);
},
toProto(message) {
return exports.AppDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.AppDescriptor",
value: exports.AppDescriptor.encode(message).finish()
};
},
registerTypeUrl() {
if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.AppDescriptor.typeUrl)) {
return;
}
exports.AuthnDescriptor.registerTypeUrl();
exports.ChainDescriptor.registerTypeUrl();
exports.CodecDescriptor.registerTypeUrl();
exports.ConfigurationDescriptor.registerTypeUrl();
exports.QueryServicesDescriptor.registerTypeUrl();
exports.TxDescriptor.registerTypeUrl();
}
};
function createBaseTxDescriptor() {
return {
fullname: "",
msgs: []
};
}
/**
* TxDescriptor describes the accepted transaction type
* @name TxDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.TxDescriptor
*/
exports.TxDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.TxDescriptor",
aminoType: "cosmos-sdk/TxDescriptor",
is(o) {
return o && (o.$typeUrl === exports.TxDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.msgs) && (!o.msgs.length || exports.MsgDescriptor.is(o.msgs[0])));
},
isAmino(o) {
return o && (o.$typeUrl === exports.TxDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.msgs) && (!o.msgs.length || exports.MsgDescriptor.isAmino(o.msgs[0])));
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.fullname !== "") {
writer.uint32(10).string(message.fullname);
}
for (const v of message.msgs) {
exports.MsgDescriptor.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(exports.MsgDescriptor.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseTxDescriptor();
message.fullname = object.fullname ?? "";
message.msgs = object.msgs?.map(e => exports.MsgDescriptor.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseTxDescriptor();
if (object.fullname !== undefined && object.fullname !== null) {
message.fullname = object.fullname;
}
message.msgs = object.msgs?.map(e => exports.MsgDescriptor.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.fullname = message.fullname === "" ? undefined : message.fullname;
if (message.msgs) {
obj.msgs = message.msgs.map(e => e ? exports.MsgDescriptor.toAmino(e) : undefined);
}
else {
obj.msgs = message.msgs;
}
return obj;
},
fromAminoMsg(object) {
return exports.TxDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/TxDescriptor",
value: exports.TxDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.TxDescriptor.decode(message.value);
},
toProto(message) {
return exports.TxDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.TxDescriptor",
value: exports.TxDescriptor.encode(message).finish()
};
},
registerTypeUrl() {
if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.TxDescriptor.typeUrl)) {
return;
}
exports.MsgDescriptor.registerTypeUrl();
}
};
function createBaseAuthnDescriptor() {
return {
signModes: []
};
}
/**
* AuthnDescriptor provides information on how to sign transactions without relying
* on the online RPCs GetTxMetadata and CombineUnsignedTxAndSignatures
* @name AuthnDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.AuthnDescriptor
*/
exports.AuthnDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.AuthnDescriptor",
aminoType: "cosmos-sdk/AuthnDescriptor",
is(o) {
return o && (o.$typeUrl === exports.AuthnDescriptor.typeUrl || Array.isArray(o.signModes) && (!o.signModes.length || exports.SigningModeDescriptor.is(o.signModes[0])));
},
isAmino(o) {
return o && (o.$typeUrl === exports.AuthnDescriptor.typeUrl || Array.isArray(o.sign_modes) && (!o.sign_modes.length || exports.SigningModeDescriptor.isAmino(o.sign_modes[0])));
},
encode(message, writer = binary_1.BinaryWriter.create()) {
for (const v of message.signModes) {
exports.SigningModeDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(exports.SigningModeDescriptor.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseAuthnDescriptor();
message.signModes = object.signModes?.map(e => exports.SigningModeDescriptor.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseAuthnDescriptor();
message.signModes = object.sign_modes?.map(e => exports.SigningModeDescriptor.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
if (message.signModes) {
obj.sign_modes = message.signModes.map(e => e ? exports.SigningModeDescriptor.toAmino(e) : undefined);
}
else {
obj.sign_modes = message.signModes;
}
return obj;
},
fromAminoMsg(object) {
return exports.AuthnDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/AuthnDescriptor",
value: exports.AuthnDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.AuthnDescriptor.decode(message.value);
},
toProto(message) {
return exports.AuthnDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.AuthnDescriptor",
value: exports.AuthnDescriptor.encode(message).finish()
};
},
registerTypeUrl() {
if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.AuthnDescriptor.typeUrl)) {
return;
}
exports.SigningModeDescriptor.registerTypeUrl();
}
};
function createBaseSigningModeDescriptor() {
return {
name: "",
number: 0,
authnInfoProviderMethodFullname: ""
};
}
/**
* SigningModeDescriptor provides information on a signing flow of the application
* NOTE(fdymylja): here we could go as far as providing an entire flow on how
* to sign a message given a SigningModeDescriptor, but it's better to think about
* this another time
* @name SigningModeDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.SigningModeDescriptor
*/
exports.SigningModeDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.SigningModeDescriptor",
aminoType: "cosmos-sdk/SigningModeDescriptor",
is(o) {
return o && (o.$typeUrl === exports.SigningModeDescriptor.typeUrl || typeof o.name === "string" && typeof o.number === "number" && typeof o.authnInfoProviderMethodFullname === "string");
},
isAmino(o) {
return o && (o.$typeUrl === exports.SigningModeDescriptor.typeUrl || typeof o.name === "string" && typeof o.number === "number" && typeof o.authn_info_provider_method_fullname === "string");
},
encode(message, writer = binary_1.BinaryWriter.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseSigningModeDescriptor();
message.name = object.name ?? "";
message.number = object.number ?? 0;
message.authnInfoProviderMethodFullname = object.authnInfoProviderMethodFullname ?? "";
return message;
},
fromAmino(object) {
const message = createBaseSigningModeDescriptor();
if (object.name !== undefined && object.name !== null) {
message.name = object.name;
}
if (object.number !== undefined && object.number !== null) {
message.number = object.number;
}
if (object.authn_info_provider_method_fullname !== undefined && object.authn_info_provider_method_fullname !== null) {
message.authnInfoProviderMethodFullname = object.authn_info_provider_method_fullname;
}
return message;
},
toAmino(message) {
const obj = {};
obj.name = message.name === "" ? undefined : message.name;
obj.number = message.number === 0 ? undefined : message.number;
obj.authn_info_provider_method_fullname = message.authnInfoProviderMethodFullname === "" ? undefined : message.authnInfoProviderMethodFullname;
return obj;
},
fromAminoMsg(object) {
return exports.SigningModeDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/SigningModeDescriptor",
value: exports.SigningModeDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.SigningModeDescriptor.decode(message.value);
},
toProto(message) {
return exports.SigningModeDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.SigningModeDescriptor",
value: exports.SigningModeDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseChainDescriptor() {
return {
id: ""
};
}
/**
* ChainDescriptor describes chain information of the application
* @name ChainDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.ChainDescriptor
*/
exports.ChainDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.ChainDescriptor",
aminoType: "cosmos-sdk/ChainDescriptor",
is(o) {
return o && (o.$typeUrl === exports.ChainDescriptor.typeUrl || typeof o.id === "string");
},
isAmino(o) {
return o && (o.$typeUrl === exports.ChainDescriptor.typeUrl || typeof o.id === "string");
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.id !== "") {
writer.uint32(10).string(message.id);
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseChainDescriptor();
message.id = object.id ?? "";
return message;
},
fromAmino(object) {
const message = createBaseChainDescriptor();
if (object.id !== undefined && object.id !== null) {
message.id = object.id;
}
return message;
},
toAmino(message) {
const obj = {};
obj.id = message.id === "" ? undefined : message.id;
return obj;
},
fromAminoMsg(object) {
return exports.ChainDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/ChainDescriptor",
value: exports.ChainDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.ChainDescriptor.decode(message.value);
},
toProto(message) {
return exports.ChainDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.ChainDescriptor",
value: exports.ChainDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseCodecDescriptor() {
return {
interfaces: []
};
}
/**
* CodecDescriptor describes the registered interfaces and provides metadata information on the types
* @name CodecDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.CodecDescriptor
*/
exports.CodecDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.CodecDescriptor",
aminoType: "cosmos-sdk/CodecDescriptor",
is(o) {
return o && (o.$typeUrl === exports.CodecDescriptor.typeUrl || Array.isArray(o.interfaces) && (!o.interfaces.length || exports.InterfaceDescriptor.is(o.interfaces[0])));
},
isAmino(o) {
return o && (o.$typeUrl === exports.CodecDescriptor.typeUrl || Array.isArray(o.interfaces) && (!o.interfaces.length || exports.InterfaceDescriptor.isAmino(o.interfaces[0])));
},
encode(message, writer = binary_1.BinaryWriter.create()) {
for (const v of message.interfaces) {
exports.InterfaceDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(exports.InterfaceDescriptor.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseCodecDescriptor();
message.interfaces = object.interfaces?.map(e => exports.InterfaceDescriptor.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseCodecDescriptor();
message.interfaces = object.interfaces?.map(e => exports.InterfaceDescriptor.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
if (message.interfaces) {
obj.interfaces = message.interfaces.map(e => e ? exports.InterfaceDescriptor.toAmino(e) : undefined);
}
else {
obj.interfaces = message.interfaces;
}
return obj;
},
fromAminoMsg(object) {
return exports.CodecDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/CodecDescriptor",
value: exports.CodecDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.CodecDescriptor.decode(message.value);
},
toProto(message) {
return exports.CodecDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.CodecDescriptor",
value: exports.CodecDescriptor.encode(message).finish()
};
},
registerTypeUrl() {
if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.CodecDescriptor.typeUrl)) {
return;
}
exports.InterfaceDescriptor.registerTypeUrl();
}
};
function createBaseInterfaceDescriptor() {
return {
fullname: "",
interfaceAcceptingMessages: [],
interfaceImplementers: []
};
}
/**
* InterfaceDescriptor describes the implementation of an interface
* @name InterfaceDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.InterfaceDescriptor
*/
exports.InterfaceDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceDescriptor",
aminoType: "cosmos-sdk/InterfaceDescriptor",
is(o) {
return o && (o.$typeUrl === exports.InterfaceDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.interfaceAcceptingMessages) && (!o.interfaceAcceptingMessages.length || exports.InterfaceAcceptingMessageDescriptor.is(o.interfaceAcceptingMessages[0])) && Array.isArray(o.interfaceImplementers) && (!o.interfaceImplementers.length || exports.InterfaceImplementerDescriptor.is(o.interfaceImplementers[0])));
},
isAmino(o) {
return o && (o.$typeUrl === exports.InterfaceDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.interface_accepting_messages) && (!o.interface_accepting_messages.length || exports.InterfaceAcceptingMessageDescriptor.isAmino(o.interface_accepting_messages[0])) && Array.isArray(o.interface_implementers) && (!o.interface_implementers.length || exports.InterfaceImplementerDescriptor.isAmino(o.interface_implementers[0])));
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.fullname !== "") {
writer.uint32(10).string(message.fullname);
}
for (const v of message.interfaceAcceptingMessages) {
exports.InterfaceAcceptingMessageDescriptor.encode(v, writer.uint32(18).fork()).ldelim();
}
for (const v of message.interfaceImplementers) {
exports.InterfaceImplementerDescriptor.encode(v, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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(exports.InterfaceAcceptingMessageDescriptor.decode(reader, reader.uint32()));
break;
case 3:
message.interfaceImplementers.push(exports.InterfaceImplementerDescriptor.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseInterfaceDescriptor();
message.fullname = object.fullname ?? "";
message.interfaceAcceptingMessages = object.interfaceAcceptingMessages?.map(e => exports.InterfaceAcceptingMessageDescriptor.fromPartial(e)) || [];
message.interfaceImplementers = object.interfaceImplementers?.map(e => exports.InterfaceImplementerDescriptor.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseInterfaceDescriptor();
if (object.fullname !== undefined && object.fullname !== null) {
message.fullname = object.fullname;
}
message.interfaceAcceptingMessages = object.interface_accepting_messages?.map(e => exports.InterfaceAcceptingMessageDescriptor.fromAmino(e)) || [];
message.interfaceImplementers = object.interface_implementers?.map(e => exports.InterfaceImplementerDescriptor.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.fullname = message.fullname === "" ? undefined : message.fullname;
if (message.interfaceAcceptingMessages) {
obj.interface_accepting_messages = message.interfaceAcceptingMessages.map(e => e ? exports.InterfaceAcceptingMessageDescriptor.toAmino(e) : undefined);
}
else {
obj.interface_accepting_messages = message.interfaceAcceptingMessages;
}
if (message.interfaceImplementers) {
obj.interface_implementers = message.interfaceImplementers.map(e => e ? exports.InterfaceImplementerDescriptor.toAmino(e) : undefined);
}
else {
obj.interface_implementers = message.interfaceImplementers;
}
return obj;
},
fromAminoMsg(object) {
return exports.InterfaceDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/InterfaceDescriptor",
value: exports.InterfaceDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.InterfaceDescriptor.decode(message.value);
},
toProto(message) {
return exports.InterfaceDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceDescriptor",
value: exports.InterfaceDescriptor.encode(message).finish()
};
},
registerTypeUrl() {
if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.InterfaceDescriptor.typeUrl)) {
return;
}
exports.InterfaceAcceptingMessageDescriptor.registerTypeUrl();
exports.InterfaceImplementerDescriptor.registerTypeUrl();
}
};
function createBaseInterfaceImplementerDescriptor() {
return {
fullname: "",
typeUrl: ""
};
}
/**
* InterfaceImplementerDescriptor describes an interface implementer
* @name InterfaceImplementerDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor
*/
exports.InterfaceImplementerDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor",
aminoType: "cosmos-sdk/InterfaceImplementerDescriptor",
is(o) {
return o && (o.$typeUrl === exports.InterfaceImplementerDescriptor.typeUrl || typeof o.fullname === "string" && typeof o.typeUrl === "string");
},
isAmino(o) {
return o && (o.$typeUrl === exports.InterfaceImplementerDescriptor.typeUrl || typeof o.fullname === "string" && typeof o.type_url === "string");
},
encode(message, writer = binary_1.BinaryWriter.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseInterfaceImplementerDescriptor();
message.fullname = object.fullname ?? "";
message.typeUrl = object.typeUrl ?? "";
return message;
},
fromAmino(object) {
const message = createBaseInterfaceImplementerDescriptor();
if (object.fullname !== undefined && object.fullname !== null) {
message.fullname = object.fullname;
}
if (object.type_url !== undefined && object.type_url !== null) {
message.typeUrl = object.type_url;
}
return message;
},
toAmino(message) {
const obj = {};
obj.fullname = message.fullname === "" ? undefined : message.fullname;
obj.type_url = message.typeUrl === "" ? undefined : message.typeUrl;
return obj;
},
fromAminoMsg(object) {
return exports.InterfaceImplementerDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/InterfaceImplementerDescriptor",
value: exports.InterfaceImplementerDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.InterfaceImplementerDescriptor.decode(message.value);
},
toProto(message) {
return exports.InterfaceImplementerDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor",
value: exports.InterfaceImplementerDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseInterfaceAcceptingMessageDescriptor() {
return {
fullname: "",
fieldDescriptorNames: []
};
}
/**
* InterfaceAcceptingMessageDescriptor describes a protobuf message which contains
* an interface represented as a google.protobuf.Any
* @name InterfaceAcceptingMessageDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor
*/
exports.InterfaceAcceptingMessageDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor",
aminoType: "cosmos-sdk/InterfaceAcceptingMessageDescriptor",
is(o) {
return o && (o.$typeUrl === exports.InterfaceAcceptingMessageDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.fieldDescriptorNames) && (!o.fieldDescriptorNames.length || typeof o.fieldDescriptorNames[0] === "string"));
},
isAmino(o) {
return o && (o.$typeUrl === exports.InterfaceAcceptingMessageDescriptor.typeUrl || typeof o.fullname === "string" && Array.isArray(o.field_descriptor_names) && (!o.field_descriptor_names.length || typeof o.field_descriptor_names[0] === "string"));
},
encode(message, writer = binary_1.BinaryWriter.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 binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseInterfaceAcceptingMessageDescriptor();
message.fullname = object.fullname ?? "";
message.fieldDescriptorNames = object.fieldDescriptorNames?.map(e => e) || [];
return message;
},
fromAmino(object) {
const message = createBaseInterfaceAcceptingMessageDescriptor();
if (object.fullname !== undefined && object.fullname !== null) {
message.fullname = object.fullname;
}
message.fieldDescriptorNames = object.field_descriptor_names?.map(e => e) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.fullname = message.fullname === "" ? undefined : message.fullname;
if (message.fieldDescriptorNames) {
obj.field_descriptor_names = message.fieldDescriptorNames.map(e => e);
}
else {
obj.field_descriptor_names = message.fieldDescriptorNames;
}
return obj;
},
fromAminoMsg(object) {
return exports.InterfaceAcceptingMessageDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/InterfaceAcceptingMessageDescriptor",
value: exports.InterfaceAcceptingMessageDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.InterfaceAcceptingMessageDescriptor.decode(message.value);
},
toProto(message) {
return exports.InterfaceAcceptingMessageDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor",
value: exports.InterfaceAcceptingMessageDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseConfigurationDescriptor() {
return {
bech32AccountAddressPrefix: ""
};
}
/**
* ConfigurationDescriptor contains metadata information on the sdk.Config
* @name ConfigurationDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.ConfigurationDescriptor
*/
exports.ConfigurationDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.ConfigurationDescriptor",
aminoType: "cosmos-sdk/ConfigurationDescriptor",
is(o) {
return o && (o.$typeUrl === exports.ConfigurationDescriptor.typeUrl || typeof o.bech32AccountAddressPrefix === "string");
},
isAmino(o) {
return o && (o.$typeUrl === exports.ConfigurationDescriptor.typeUrl || typeof o.bech32_account_address_prefix === "string");
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.bech32AccountAddressPrefix !== "") {
writer.uint32(10).string(message.bech32AccountAddressPrefix);
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseConfigurationDescriptor();
message.bech32AccountAddressPrefix = object.bech32AccountAddressPrefix ?? "";
return message;
},
fromAmino(object) {
const message = createBaseConfigurationDescriptor();
if (object.bech32_account_address_prefix !== undefined && object.bech32_account_address_prefix !== null) {
message.bech32AccountAddressPrefix = object.bech32_account_address_prefix;
}
return message;
},
toAmino(message) {
const obj = {};
obj.bech32_account_address_prefix = message.bech32AccountAddressPrefix === "" ? undefined : message.bech32AccountAddressPrefix;
return obj;
},
fromAminoMsg(object) {
return exports.ConfigurationDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/ConfigurationDescriptor",
value: exports.ConfigurationDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.ConfigurationDescriptor.decode(message.value);
},
toProto(message) {
return exports.ConfigurationDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.ConfigurationDescriptor",
value: exports.ConfigurationDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseMsgDescriptor() {
return {
msgTypeUrl: ""
};
}
/**
* MsgDescriptor describes a cosmos-sdk message that can be delivered with a transaction
* @name MsgDescriptor
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.MsgDescriptor
*/
exports.MsgDescriptor = {
typeUrl: "/cosmos.base.reflection.v2alpha1.MsgDescriptor",
aminoType: "cosmos-sdk/MsgDescriptor",
is(o) {
return o && (o.$typeUrl === exports.MsgDescriptor.typeUrl || typeof o.msgTypeUrl === "string");
},
isAmino(o) {
return o && (o.$typeUrl === exports.MsgDescriptor.typeUrl || typeof o.msg_type_url === "string");
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.msgTypeUrl !== "") {
writer.uint32(10).string(message.msgTypeUrl);
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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) {
const message = createBaseMsgDescriptor();
message.msgTypeUrl = object.msgTypeUrl ?? "";
return message;
},
fromAmino(object) {
const message = createBaseMsgDescriptor();
if (object.msg_type_url !== undefined && object.msg_type_url !== null) {
message.msgTypeUrl = object.msg_type_url;
}
return message;
},
toAmino(message) {
const obj = {};
obj.msg_type_url = message.msgTypeUrl === "" ? undefined : message.msgTypeUrl;
return obj;
},
fromAminoMsg(object) {
return exports.MsgDescriptor.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/MsgDescriptor",
value: exports.MsgDescriptor.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.MsgDescriptor.decode(message.value);
},
toProto(message) {
return exports.MsgDescriptor.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.MsgDescriptor",
value: exports.MsgDescriptor.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseGetAuthnDescriptorRequest() {
return {};
}
/**
* GetAuthnDescriptorRequest is the request used for the GetAuthnDescriptor RPC
* @name GetAuthnDescriptorRequest
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest
*/
exports.GetAuthnDescriptorRequest = {
typeUrl: "/cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest",
aminoType: "cosmos-sdk/GetAuthnDescriptorRequest",
is(o) {
return o && o.$typeUrl === exports.GetAuthnDescriptorRequest.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === exports.GetAuthnDescriptorRequest.typeUrl;
},
encode(_, writer = binary_1.BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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;
},
fromAmino(_) {
const message = createBaseGetAuthnDescriptorRequest();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return exports.GetAuthnDescriptorRequest.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "cosmos-sdk/GetAuthnDescriptorRequest",
value: exports.GetAuthnDescriptorRequest.toAmino(message)
};
},
fromProtoMsg(message) {
return exports.GetAuthnDescriptorRequest.decode(message.value);
},
toProto(message) {
return exports.GetAuthnDescriptorRequest.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest",
value: exports.GetAuthnDescriptorRequest.encode(message).finish()
};
},
registerTypeUrl() { }
};
function createBaseGetAuthnDescriptorResponse() {
return {
authn: undefined
};
}
/**
* GetAuthnDescriptorResponse is the response returned by the GetAuthnDescriptor RPC
* @name GetAuthnDescriptorResponse
* @package cosmos.base.reflection.v2alpha1
* @see proto type: cosmos.base.reflection.v2alpha1.GetAuthnDescriptorResponse
*/
exports.GetAuthnDescriptorResponse = {
typeUrl: "/cosmos.base.reflection.v2alpha1.GetAuthnDescriptorResponse",
aminoType: "cosmos-sdk/GetAuthnDescriptorResponse",
is(o) {
return o && o.$typeUrl === exports.GetAuthnDescriptorResponse.typeUrl;
},
isAmino(o) {
return o && o.$typeUrl === exports.GetAuthnDescriptorResponse.typeUrl;
},
encode(message, writer = binary_1.BinaryWriter.create()) {
if (message.authn !== undefined) {
exports.AuthnDescriptor.encode(message.authn, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(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 = exports.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 ? exports.AuthnDescriptor.fromPartial(object.authn) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseGetAuthnDescriptorResponse();
if (object.authn !== undefined && object.authn !== null) {
message.authn = exports.AuthnDescriptor.fromAmino(object.authn);
}
return message;
},
toAmino(message) {
const obj = {};
obj.authn = message.authn ? exports.AuthnDescriptor.toAmino(message