From b66b67793d767a5a75a85e67ecfbbebcbcbb6622 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 5 Aug 2020 13:12:06 +0200 Subject: [PATCH] proto-signing: Update generated codecimpl --- .../src/generated/codecimpl.d.ts | 664 ++++++++++++++++++ .../proto-signing/src/generated/codecimpl.js | 549 +++++++++++++++ .../types/generated/codecimpl.d.ts | 664 ++++++++++++++++++ 3 files changed, 1877 insertions(+) diff --git a/packages/proto-signing/src/generated/codecimpl.d.ts b/packages/proto-signing/src/generated/codecimpl.d.ts index 63a4519b..6b799286 100644 --- a/packages/proto-signing/src/generated/codecimpl.d.ts +++ b/packages/proto-signing/src/generated/codecimpl.d.ts @@ -473,6 +473,268 @@ export namespace cosmos { public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.TxData; } + /** Properties of a TxResponse. */ + interface ITxResponse { + /** TxResponse height */ + height?: number | Long | null; + + /** TxResponse txhash */ + txhash?: string | null; + + /** TxResponse codespace */ + codespace?: string | null; + + /** TxResponse code */ + code?: number | null; + + /** TxResponse data */ + data?: string | null; + + /** TxResponse rawLog */ + rawLog?: string | null; + + /** TxResponse logs */ + logs?: cosmos.IABCIMessageLog[] | null; + + /** TxResponse info */ + info?: string | null; + + /** TxResponse gasWanted */ + gasWanted?: number | Long | null; + + /** TxResponse gasUsed */ + gasUsed?: number | Long | null; + + /** TxResponse tx */ + tx?: google.protobuf.IAny | null; + + /** TxResponse timestamp */ + timestamp?: string | null; + } + + /** Represents a TxResponse. */ + class TxResponse implements ITxResponse { + /** + * Constructs a new TxResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.ITxResponse); + + /** TxResponse height. */ + public height: number | Long; + + /** TxResponse txhash. */ + public txhash: string; + + /** TxResponse codespace. */ + public codespace: string; + + /** TxResponse code. */ + public code: number; + + /** TxResponse data. */ + public data: string; + + /** TxResponse rawLog. */ + public rawLog: string; + + /** TxResponse logs. */ + public logs: cosmos.IABCIMessageLog[]; + + /** TxResponse info. */ + public info: string; + + /** TxResponse gasWanted. */ + public gasWanted: number | Long; + + /** TxResponse gasUsed. */ + public gasUsed: number | Long; + + /** TxResponse tx. */ + public tx?: google.protobuf.IAny | null; + + /** TxResponse timestamp. */ + public timestamp: string; + + /** + * Creates a new TxResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns TxResponse instance + */ + public static create(properties?: cosmos.ITxResponse): cosmos.TxResponse; + + /** + * Encodes the specified TxResponse message. Does not implicitly {@link cosmos.TxResponse.verify|verify} messages. + * @param m TxResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.ITxResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TxResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns TxResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.TxResponse; + } + + /** Properties of a ABCIMessageLog. */ + interface IABCIMessageLog { + /** ABCIMessageLog msgIndex */ + msgIndex?: number | null; + + /** ABCIMessageLog log */ + log?: string | null; + + /** ABCIMessageLog events */ + events?: cosmos.IStringEvent[] | null; + } + + /** Represents a ABCIMessageLog. */ + class ABCIMessageLog implements IABCIMessageLog { + /** + * Constructs a new ABCIMessageLog. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IABCIMessageLog); + + /** ABCIMessageLog msgIndex. */ + public msgIndex: number; + + /** ABCIMessageLog log. */ + public log: string; + + /** ABCIMessageLog events. */ + public events: cosmos.IStringEvent[]; + + /** + * Creates a new ABCIMessageLog instance using the specified properties. + * @param [properties] Properties to set + * @returns ABCIMessageLog instance + */ + public static create(properties?: cosmos.IABCIMessageLog): cosmos.ABCIMessageLog; + + /** + * Encodes the specified ABCIMessageLog message. Does not implicitly {@link cosmos.ABCIMessageLog.verify|verify} messages. + * @param m ABCIMessageLog message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IABCIMessageLog, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ABCIMessageLog message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ABCIMessageLog + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.ABCIMessageLog; + } + + /** Properties of a StringEvent. */ + interface IStringEvent { + /** StringEvent type */ + type?: string | null; + + /** StringEvent attributes */ + attributes?: cosmos.IAttribute[] | null; + } + + /** Represents a StringEvent. */ + class StringEvent implements IStringEvent { + /** + * Constructs a new StringEvent. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IStringEvent); + + /** StringEvent type. */ + public type: string; + + /** StringEvent attributes. */ + public attributes: cosmos.IAttribute[]; + + /** + * Creates a new StringEvent instance using the specified properties. + * @param [properties] Properties to set + * @returns StringEvent instance + */ + public static create(properties?: cosmos.IStringEvent): cosmos.StringEvent; + + /** + * Encodes the specified StringEvent message. Does not implicitly {@link cosmos.StringEvent.verify|verify} messages. + * @param m StringEvent message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IStringEvent, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a StringEvent message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns StringEvent + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.StringEvent; + } + + /** Properties of an Attribute. */ + interface IAttribute { + /** Attribute key */ + key?: string | null; + + /** Attribute value */ + value?: string | null; + } + + /** Represents an Attribute. */ + class Attribute implements IAttribute { + /** + * Constructs a new Attribute. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IAttribute); + + /** Attribute key. */ + public key: string; + + /** Attribute value. */ + public value: string; + + /** + * Creates a new Attribute instance using the specified properties. + * @param [properties] Properties to set + * @returns Attribute instance + */ + public static create(properties?: cosmos.IAttribute): cosmos.Attribute; + + /** + * Encodes the specified Attribute message. Does not implicitly {@link cosmos.Attribute.verify|verify} messages. + * @param m Attribute message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IAttribute, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an Attribute message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Attribute + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.Attribute; + } + /** Namespace bank. */ namespace bank { /** Properties of a Params. */ @@ -817,6 +1079,122 @@ export namespace cosmos { */ public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.Supply; } + + /** Properties of a DenomUnits. */ + interface IDenomUnits { + /** DenomUnits denom */ + denom?: string | null; + + /** DenomUnits exponent */ + exponent?: number | null; + + /** DenomUnits aliases */ + aliases?: string[] | null; + } + + /** Represents a DenomUnits. */ + class DenomUnits implements IDenomUnits { + /** + * Constructs a new DenomUnits. + * @param [p] Properties to set + */ + constructor(p?: cosmos.bank.IDenomUnits); + + /** DenomUnits denom. */ + public denom: string; + + /** DenomUnits exponent. */ + public exponent: number; + + /** DenomUnits aliases. */ + public aliases: string[]; + + /** + * Creates a new DenomUnits instance using the specified properties. + * @param [properties] Properties to set + * @returns DenomUnits instance + */ + public static create(properties?: cosmos.bank.IDenomUnits): cosmos.bank.DenomUnits; + + /** + * Encodes the specified DenomUnits message. Does not implicitly {@link cosmos.bank.DenomUnits.verify|verify} messages. + * @param m DenomUnits message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.bank.IDenomUnits, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DenomUnits message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DenomUnits + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.DenomUnits; + } + + /** Properties of a Metadata. */ + interface IMetadata { + /** Metadata description */ + description?: string | null; + + /** Metadata denomUnits */ + denomUnits?: cosmos.bank.IDenomUnits[] | null; + + /** Metadata base */ + base?: string | null; + + /** Metadata display */ + display?: string | null; + } + + /** Represents a Metadata. */ + class Metadata implements IMetadata { + /** + * Constructs a new Metadata. + * @param [p] Properties to set + */ + constructor(p?: cosmos.bank.IMetadata); + + /** Metadata description. */ + public description: string; + + /** Metadata denomUnits. */ + public denomUnits: cosmos.bank.IDenomUnits[]; + + /** Metadata base. */ + public base: string; + + /** Metadata display. */ + public display: string; + + /** + * Creates a new Metadata instance using the specified properties. + * @param [properties] Properties to set + * @returns Metadata instance + */ + public static create(properties?: cosmos.bank.IMetadata): cosmos.bank.Metadata; + + /** + * Encodes the specified Metadata message. Does not implicitly {@link cosmos.bank.Metadata.verify|verify} messages. + * @param m Metadata message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.bank.IMetadata, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Metadata message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Metadata + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.Metadata; + } } /** Namespace crypto. */ @@ -1592,6 +1970,292 @@ export namespace cosmos { SIGN_MODE_TEXTUAL = 2, SIGN_MODE_LEGACY_AMINO_JSON = 127, } + + /** Properties of a SignatureDescriptors. */ + interface ISignatureDescriptors { + /** SignatureDescriptors signatures */ + signatures?: cosmos.tx.signing.ISignatureDescriptor[] | null; + } + + /** Represents a SignatureDescriptors. */ + class SignatureDescriptors implements ISignatureDescriptors { + /** + * Constructs a new SignatureDescriptors. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.ISignatureDescriptors); + + /** SignatureDescriptors signatures. */ + public signatures: cosmos.tx.signing.ISignatureDescriptor[]; + + /** + * Creates a new SignatureDescriptors instance using the specified properties. + * @param [properties] Properties to set + * @returns SignatureDescriptors instance + */ + public static create( + properties?: cosmos.tx.signing.ISignatureDescriptors, + ): cosmos.tx.signing.SignatureDescriptors; + + /** + * Encodes the specified SignatureDescriptors message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptors.verify|verify} messages. + * @param m SignatureDescriptors message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.ISignatureDescriptors, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a SignatureDescriptors message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignatureDescriptors + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptors; + } + + /** Properties of a SignatureDescriptor. */ + interface ISignatureDescriptor { + /** SignatureDescriptor publicKey */ + publicKey?: cosmos.crypto.IPublicKey | null; + + /** SignatureDescriptor data */ + data?: cosmos.tx.signing.SignatureDescriptor.IData | null; + } + + /** Represents a SignatureDescriptor. */ + class SignatureDescriptor implements ISignatureDescriptor { + /** + * Constructs a new SignatureDescriptor. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.ISignatureDescriptor); + + /** SignatureDescriptor publicKey. */ + public publicKey?: cosmos.crypto.IPublicKey | null; + + /** SignatureDescriptor data. */ + public data?: cosmos.tx.signing.SignatureDescriptor.IData | null; + + /** + * Creates a new SignatureDescriptor instance using the specified properties. + * @param [properties] Properties to set + * @returns SignatureDescriptor instance + */ + public static create( + properties?: cosmos.tx.signing.ISignatureDescriptor, + ): cosmos.tx.signing.SignatureDescriptor; + + /** + * Encodes the specified SignatureDescriptor message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.verify|verify} messages. + * @param m SignatureDescriptor message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.ISignatureDescriptor, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a SignatureDescriptor message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignatureDescriptor + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor; + } + + namespace SignatureDescriptor { + /** Properties of a Data. */ + interface IData { + /** Data single */ + single?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle | null; + + /** Data multi */ + multi?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti | null; + } + + /** Represents a Data. */ + class Data implements IData { + /** + * Constructs a new Data. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.IData); + + /** Data single. */ + public single?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle | null; + + /** Data multi. */ + public multi?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti | null; + + /** Data sum. */ + public sum?: "single" | "multi"; + + /** + * Creates a new Data instance using the specified properties. + * @param [properties] Properties to set + * @returns Data instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.IData, + ): cosmos.tx.signing.SignatureDescriptor.Data; + + /** + * Encodes the specified Data message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.verify|verify} messages. + * @param m Data message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.IData, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Data message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Data + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data; + } + + namespace Data { + /** Properties of a Single. */ + interface ISingle { + /** Single mode */ + mode?: cosmos.tx.signing.SignMode | null; + + /** Single signature */ + signature?: Uint8Array | null; + } + + /** Represents a Single. */ + class Single implements ISingle { + /** + * Constructs a new Single. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle); + + /** Single mode. */ + public mode: cosmos.tx.signing.SignMode; + + /** Single signature. */ + public signature: Uint8Array; + + /** + * Creates a new Single instance using the specified properties. + * @param [properties] Properties to set + * @returns Single instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle, + ): cosmos.tx.signing.SignatureDescriptor.Data.Single; + + /** + * Encodes the specified Single message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.Single.verify|verify} messages. + * @param m Single message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.Data.ISingle, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Single message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Single + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data.Single; + } + + /** Properties of a Multi. */ + interface IMulti { + /** Multi bitarray */ + bitarray?: cosmos.crypto.ICompactBitArray | null; + + /** Multi signatures */ + signatures?: cosmos.tx.signing.SignatureDescriptor.IData[] | null; + } + + /** Represents a Multi. */ + class Multi implements IMulti { + /** + * Constructs a new Multi. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti); + + /** Multi bitarray. */ + public bitarray?: cosmos.crypto.ICompactBitArray | null; + + /** Multi signatures. */ + public signatures: cosmos.tx.signing.SignatureDescriptor.IData[]; + + /** + * Creates a new Multi instance using the specified properties. + * @param [properties] Properties to set + * @returns Multi instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti, + ): cosmos.tx.signing.SignatureDescriptor.Data.Multi; + + /** + * Encodes the specified Multi message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.Multi.verify|verify} messages. + * @param m Multi message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.Data.IMulti, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Multi message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Multi + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data.Multi; + } + } + } } } } diff --git a/packages/proto-signing/src/generated/codecimpl.js b/packages/proto-signing/src/generated/codecimpl.js index f454a887..b2552d3b 100644 --- a/packages/proto-signing/src/generated/codecimpl.js +++ b/packages/proto-signing/src/generated/codecimpl.js @@ -389,6 +389,229 @@ exports.cosmos = $root.cosmos = (function () { }; return TxData; })(); + cosmos.TxResponse = (function () { + function TxResponse(p) { + this.logs = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + TxResponse.prototype.height = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + TxResponse.prototype.txhash = ""; + TxResponse.prototype.codespace = ""; + TxResponse.prototype.code = 0; + TxResponse.prototype.data = ""; + TxResponse.prototype.rawLog = ""; + TxResponse.prototype.logs = $util.emptyArray; + TxResponse.prototype.info = ""; + TxResponse.prototype.gasWanted = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + TxResponse.prototype.gasUsed = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + TxResponse.prototype.tx = null; + TxResponse.prototype.timestamp = ""; + TxResponse.create = function create(properties) { + return new TxResponse(properties); + }; + TxResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.height != null && Object.hasOwnProperty.call(m, "height")) w.uint32(8).int64(m.height); + if (m.txhash != null && Object.hasOwnProperty.call(m, "txhash")) w.uint32(18).string(m.txhash); + if (m.codespace != null && Object.hasOwnProperty.call(m, "codespace")) w.uint32(26).string(m.codespace); + if (m.code != null && Object.hasOwnProperty.call(m, "code")) w.uint32(32).uint32(m.code); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(42).string(m.data); + if (m.rawLog != null && Object.hasOwnProperty.call(m, "rawLog")) w.uint32(50).string(m.rawLog); + if (m.logs != null && m.logs.length) { + for (var i = 0; i < m.logs.length; ++i) + $root.cosmos.ABCIMessageLog.encode(m.logs[i], w.uint32(58).fork()).ldelim(); + } + if (m.info != null && Object.hasOwnProperty.call(m, "info")) w.uint32(66).string(m.info); + if (m.gasWanted != null && Object.hasOwnProperty.call(m, "gasWanted")) w.uint32(72).int64(m.gasWanted); + if (m.gasUsed != null && Object.hasOwnProperty.call(m, "gasUsed")) w.uint32(80).int64(m.gasUsed); + if (m.tx != null && Object.hasOwnProperty.call(m, "tx")) + $root.google.protobuf.Any.encode(m.tx, w.uint32(90).fork()).ldelim(); + if (m.timestamp != null && Object.hasOwnProperty.call(m, "timestamp")) w.uint32(98).string(m.timestamp); + return w; + }; + TxResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.TxResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.height = r.int64(); + break; + case 2: + m.txhash = r.string(); + break; + case 3: + m.codespace = r.string(); + break; + case 4: + m.code = r.uint32(); + break; + case 5: + m.data = r.string(); + break; + case 6: + m.rawLog = r.string(); + break; + case 7: + if (!(m.logs && m.logs.length)) m.logs = []; + m.logs.push($root.cosmos.ABCIMessageLog.decode(r, r.uint32())); + break; + case 8: + m.info = r.string(); + break; + case 9: + m.gasWanted = r.int64(); + break; + case 10: + m.gasUsed = r.int64(); + break; + case 11: + m.tx = $root.google.protobuf.Any.decode(r, r.uint32()); + break; + case 12: + m.timestamp = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return TxResponse; + })(); + cosmos.ABCIMessageLog = (function () { + function ABCIMessageLog(p) { + this.events = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ABCIMessageLog.prototype.msgIndex = 0; + ABCIMessageLog.prototype.log = ""; + ABCIMessageLog.prototype.events = $util.emptyArray; + ABCIMessageLog.create = function create(properties) { + return new ABCIMessageLog(properties); + }; + ABCIMessageLog.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.msgIndex != null && Object.hasOwnProperty.call(m, "msgIndex")) w.uint32(8).uint32(m.msgIndex); + if (m.log != null && Object.hasOwnProperty.call(m, "log")) w.uint32(18).string(m.log); + if (m.events != null && m.events.length) { + for (var i = 0; i < m.events.length; ++i) + $root.cosmos.StringEvent.encode(m.events[i], w.uint32(26).fork()).ldelim(); + } + return w; + }; + ABCIMessageLog.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.ABCIMessageLog(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.msgIndex = r.uint32(); + break; + case 2: + m.log = r.string(); + break; + case 3: + if (!(m.events && m.events.length)) m.events = []; + m.events.push($root.cosmos.StringEvent.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ABCIMessageLog; + })(); + cosmos.StringEvent = (function () { + function StringEvent(p) { + this.attributes = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + StringEvent.prototype.type = ""; + StringEvent.prototype.attributes = $util.emptyArray; + StringEvent.create = function create(properties) { + return new StringEvent(properties); + }; + StringEvent.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.type != null && Object.hasOwnProperty.call(m, "type")) w.uint32(10).string(m.type); + if (m.attributes != null && m.attributes.length) { + for (var i = 0; i < m.attributes.length; ++i) + $root.cosmos.Attribute.encode(m.attributes[i], w.uint32(18).fork()).ldelim(); + } + return w; + }; + StringEvent.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.StringEvent(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.type = r.string(); + break; + case 2: + if (!(m.attributes && m.attributes.length)) m.attributes = []; + m.attributes.push($root.cosmos.Attribute.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return StringEvent; + })(); + cosmos.Attribute = (function () { + function Attribute(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Attribute.prototype.key = ""; + Attribute.prototype.value = ""; + Attribute.create = function create(properties) { + return new Attribute(properties); + }; + Attribute.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.key != null && Object.hasOwnProperty.call(m, "key")) w.uint32(10).string(m.key); + if (m.value != null && Object.hasOwnProperty.call(m, "value")) w.uint32(18).string(m.value); + return w; + }; + Attribute.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.Attribute(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.key = r.string(); + break; + case 2: + m.value = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Attribute; + })(); cosmos.bank = (function () { var bank = {}; bank.Params = (function () { @@ -702,6 +925,109 @@ exports.cosmos = $root.cosmos = (function () { }; return Supply; })(); + bank.DenomUnits = (function () { + function DenomUnits(p) { + this.aliases = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DenomUnits.prototype.denom = ""; + DenomUnits.prototype.exponent = 0; + DenomUnits.prototype.aliases = $util.emptyArray; + DenomUnits.create = function create(properties) { + return new DenomUnits(properties); + }; + DenomUnits.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.denom != null && Object.hasOwnProperty.call(m, "denom")) w.uint32(10).string(m.denom); + if (m.exponent != null && Object.hasOwnProperty.call(m, "exponent")) w.uint32(16).uint32(m.exponent); + if (m.aliases != null && m.aliases.length) { + for (var i = 0; i < m.aliases.length; ++i) w.uint32(26).string(m.aliases[i]); + } + return w; + }; + DenomUnits.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.bank.DenomUnits(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.denom = r.string(); + break; + case 2: + m.exponent = r.uint32(); + break; + case 3: + if (!(m.aliases && m.aliases.length)) m.aliases = []; + m.aliases.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DenomUnits; + })(); + bank.Metadata = (function () { + function Metadata(p) { + this.denomUnits = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Metadata.prototype.description = ""; + Metadata.prototype.denomUnits = $util.emptyArray; + Metadata.prototype.base = ""; + Metadata.prototype.display = ""; + Metadata.create = function create(properties) { + return new Metadata(properties); + }; + Metadata.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.description != null && Object.hasOwnProperty.call(m, "description")) + w.uint32(10).string(m.description); + if (m.denomUnits != null && m.denomUnits.length) { + for (var i = 0; i < m.denomUnits.length; ++i) + $root.cosmos.bank.DenomUnits.encode(m.denomUnits[i], w.uint32(18).fork()).ldelim(); + } + if (m.base != null && Object.hasOwnProperty.call(m, "base")) w.uint32(26).string(m.base); + if (m.display != null && Object.hasOwnProperty.call(m, "display")) w.uint32(34).string(m.display); + return w; + }; + Metadata.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.bank.Metadata(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.description = r.string(); + break; + case 2: + if (!(m.denomUnits && m.denomUnits.length)) m.denomUnits = []; + m.denomUnits.push($root.cosmos.bank.DenomUnits.decode(r, r.uint32())); + break; + case 3: + m.base = r.string(); + break; + case 4: + m.display = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Metadata; + })(); return bank; })(); cosmos.crypto = (function () { @@ -1401,6 +1727,229 @@ exports.cosmos = $root.cosmos = (function () { values[(valuesById[127] = "SIGN_MODE_LEGACY_AMINO_JSON")] = 127; return values; })(); + signing.SignatureDescriptors = (function () { + function SignatureDescriptors(p) { + this.signatures = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + SignatureDescriptors.prototype.signatures = $util.emptyArray; + SignatureDescriptors.create = function create(properties) { + return new SignatureDescriptors(properties); + }; + SignatureDescriptors.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.signatures != null && m.signatures.length) { + for (var i = 0; i < m.signatures.length; ++i) + $root.cosmos.tx.signing.SignatureDescriptor.encode( + m.signatures[i], + w.uint32(10).fork(), + ).ldelim(); + } + return w; + }; + SignatureDescriptors.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.tx.signing.SignatureDescriptors(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.signatures && m.signatures.length)) m.signatures = []; + m.signatures.push($root.cosmos.tx.signing.SignatureDescriptor.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return SignatureDescriptors; + })(); + signing.SignatureDescriptor = (function () { + function SignatureDescriptor(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + SignatureDescriptor.prototype.publicKey = null; + SignatureDescriptor.prototype.data = null; + SignatureDescriptor.create = function create(properties) { + return new SignatureDescriptor(properties); + }; + SignatureDescriptor.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.publicKey != null && Object.hasOwnProperty.call(m, "publicKey")) + $root.cosmos.crypto.PublicKey.encode(m.publicKey, w.uint32(10).fork()).ldelim(); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) + $root.cosmos.tx.signing.SignatureDescriptor.Data.encode(m.data, w.uint32(18).fork()).ldelim(); + return w; + }; + SignatureDescriptor.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.tx.signing.SignatureDescriptor(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.publicKey = $root.cosmos.crypto.PublicKey.decode(r, r.uint32()); + break; + case 2: + m.data = $root.cosmos.tx.signing.SignatureDescriptor.Data.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + SignatureDescriptor.Data = (function () { + function Data(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Data.prototype.single = null; + Data.prototype.multi = null; + var $oneOfFields; + Object.defineProperty(Data.prototype, "sum", { + get: $util.oneOfGetter(($oneOfFields = ["single", "multi"])), + set: $util.oneOfSetter($oneOfFields), + }); + Data.create = function create(properties) { + return new Data(properties); + }; + Data.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.single != null && Object.hasOwnProperty.call(m, "single")) + $root.cosmos.tx.signing.SignatureDescriptor.Data.Single.encode( + m.single, + w.uint32(10).fork(), + ).ldelim(); + if (m.multi != null && Object.hasOwnProperty.call(m, "multi")) + $root.cosmos.tx.signing.SignatureDescriptor.Data.Multi.encode( + m.multi, + w.uint32(18).fork(), + ).ldelim(); + return w; + }; + Data.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.tx.signing.SignatureDescriptor.Data(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.single = $root.cosmos.tx.signing.SignatureDescriptor.Data.Single.decode(r, r.uint32()); + break; + case 2: + m.multi = $root.cosmos.tx.signing.SignatureDescriptor.Data.Multi.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + Data.Single = (function () { + function Single(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Single.prototype.mode = 0; + Single.prototype.signature = $util.newBuffer([]); + Single.create = function create(properties) { + return new Single(properties); + }; + Single.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.mode != null && Object.hasOwnProperty.call(m, "mode")) w.uint32(8).int32(m.mode); + if (m.signature != null && Object.hasOwnProperty.call(m, "signature")) + w.uint32(18).bytes(m.signature); + return w; + }; + Single.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.tx.signing.SignatureDescriptor.Data.Single(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.mode = r.int32(); + break; + case 2: + m.signature = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Single; + })(); + Data.Multi = (function () { + function Multi(p) { + this.signatures = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Multi.prototype.bitarray = null; + Multi.prototype.signatures = $util.emptyArray; + Multi.create = function create(properties) { + return new Multi(properties); + }; + Multi.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.bitarray != null && Object.hasOwnProperty.call(m, "bitarray")) + $root.cosmos.crypto.CompactBitArray.encode(m.bitarray, w.uint32(10).fork()).ldelim(); + if (m.signatures != null && m.signatures.length) { + for (var i = 0; i < m.signatures.length; ++i) + $root.cosmos.tx.signing.SignatureDescriptor.Data.encode( + m.signatures[i], + w.uint32(18).fork(), + ).ldelim(); + } + return w; + }; + Multi.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.tx.signing.SignatureDescriptor.Data.Multi(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.bitarray = $root.cosmos.crypto.CompactBitArray.decode(r, r.uint32()); + break; + case 2: + if (!(m.signatures && m.signatures.length)) m.signatures = []; + m.signatures.push($root.cosmos.tx.signing.SignatureDescriptor.Data.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Multi; + })(); + return Data; + })(); + return SignatureDescriptor; + })(); return signing; })(); return tx; diff --git a/packages/proto-signing/types/generated/codecimpl.d.ts b/packages/proto-signing/types/generated/codecimpl.d.ts index 63a4519b..6b799286 100644 --- a/packages/proto-signing/types/generated/codecimpl.d.ts +++ b/packages/proto-signing/types/generated/codecimpl.d.ts @@ -473,6 +473,268 @@ export namespace cosmos { public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.TxData; } + /** Properties of a TxResponse. */ + interface ITxResponse { + /** TxResponse height */ + height?: number | Long | null; + + /** TxResponse txhash */ + txhash?: string | null; + + /** TxResponse codespace */ + codespace?: string | null; + + /** TxResponse code */ + code?: number | null; + + /** TxResponse data */ + data?: string | null; + + /** TxResponse rawLog */ + rawLog?: string | null; + + /** TxResponse logs */ + logs?: cosmos.IABCIMessageLog[] | null; + + /** TxResponse info */ + info?: string | null; + + /** TxResponse gasWanted */ + gasWanted?: number | Long | null; + + /** TxResponse gasUsed */ + gasUsed?: number | Long | null; + + /** TxResponse tx */ + tx?: google.protobuf.IAny | null; + + /** TxResponse timestamp */ + timestamp?: string | null; + } + + /** Represents a TxResponse. */ + class TxResponse implements ITxResponse { + /** + * Constructs a new TxResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.ITxResponse); + + /** TxResponse height. */ + public height: number | Long; + + /** TxResponse txhash. */ + public txhash: string; + + /** TxResponse codespace. */ + public codespace: string; + + /** TxResponse code. */ + public code: number; + + /** TxResponse data. */ + public data: string; + + /** TxResponse rawLog. */ + public rawLog: string; + + /** TxResponse logs. */ + public logs: cosmos.IABCIMessageLog[]; + + /** TxResponse info. */ + public info: string; + + /** TxResponse gasWanted. */ + public gasWanted: number | Long; + + /** TxResponse gasUsed. */ + public gasUsed: number | Long; + + /** TxResponse tx. */ + public tx?: google.protobuf.IAny | null; + + /** TxResponse timestamp. */ + public timestamp: string; + + /** + * Creates a new TxResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns TxResponse instance + */ + public static create(properties?: cosmos.ITxResponse): cosmos.TxResponse; + + /** + * Encodes the specified TxResponse message. Does not implicitly {@link cosmos.TxResponse.verify|verify} messages. + * @param m TxResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.ITxResponse, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a TxResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns TxResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.TxResponse; + } + + /** Properties of a ABCIMessageLog. */ + interface IABCIMessageLog { + /** ABCIMessageLog msgIndex */ + msgIndex?: number | null; + + /** ABCIMessageLog log */ + log?: string | null; + + /** ABCIMessageLog events */ + events?: cosmos.IStringEvent[] | null; + } + + /** Represents a ABCIMessageLog. */ + class ABCIMessageLog implements IABCIMessageLog { + /** + * Constructs a new ABCIMessageLog. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IABCIMessageLog); + + /** ABCIMessageLog msgIndex. */ + public msgIndex: number; + + /** ABCIMessageLog log. */ + public log: string; + + /** ABCIMessageLog events. */ + public events: cosmos.IStringEvent[]; + + /** + * Creates a new ABCIMessageLog instance using the specified properties. + * @param [properties] Properties to set + * @returns ABCIMessageLog instance + */ + public static create(properties?: cosmos.IABCIMessageLog): cosmos.ABCIMessageLog; + + /** + * Encodes the specified ABCIMessageLog message. Does not implicitly {@link cosmos.ABCIMessageLog.verify|verify} messages. + * @param m ABCIMessageLog message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IABCIMessageLog, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ABCIMessageLog message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ABCIMessageLog + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.ABCIMessageLog; + } + + /** Properties of a StringEvent. */ + interface IStringEvent { + /** StringEvent type */ + type?: string | null; + + /** StringEvent attributes */ + attributes?: cosmos.IAttribute[] | null; + } + + /** Represents a StringEvent. */ + class StringEvent implements IStringEvent { + /** + * Constructs a new StringEvent. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IStringEvent); + + /** StringEvent type. */ + public type: string; + + /** StringEvent attributes. */ + public attributes: cosmos.IAttribute[]; + + /** + * Creates a new StringEvent instance using the specified properties. + * @param [properties] Properties to set + * @returns StringEvent instance + */ + public static create(properties?: cosmos.IStringEvent): cosmos.StringEvent; + + /** + * Encodes the specified StringEvent message. Does not implicitly {@link cosmos.StringEvent.verify|verify} messages. + * @param m StringEvent message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IStringEvent, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a StringEvent message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns StringEvent + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.StringEvent; + } + + /** Properties of an Attribute. */ + interface IAttribute { + /** Attribute key */ + key?: string | null; + + /** Attribute value */ + value?: string | null; + } + + /** Represents an Attribute. */ + class Attribute implements IAttribute { + /** + * Constructs a new Attribute. + * @param [p] Properties to set + */ + constructor(p?: cosmos.IAttribute); + + /** Attribute key. */ + public key: string; + + /** Attribute value. */ + public value: string; + + /** + * Creates a new Attribute instance using the specified properties. + * @param [properties] Properties to set + * @returns Attribute instance + */ + public static create(properties?: cosmos.IAttribute): cosmos.Attribute; + + /** + * Encodes the specified Attribute message. Does not implicitly {@link cosmos.Attribute.verify|verify} messages. + * @param m Attribute message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.IAttribute, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an Attribute message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Attribute + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.Attribute; + } + /** Namespace bank. */ namespace bank { /** Properties of a Params. */ @@ -817,6 +1079,122 @@ export namespace cosmos { */ public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.Supply; } + + /** Properties of a DenomUnits. */ + interface IDenomUnits { + /** DenomUnits denom */ + denom?: string | null; + + /** DenomUnits exponent */ + exponent?: number | null; + + /** DenomUnits aliases */ + aliases?: string[] | null; + } + + /** Represents a DenomUnits. */ + class DenomUnits implements IDenomUnits { + /** + * Constructs a new DenomUnits. + * @param [p] Properties to set + */ + constructor(p?: cosmos.bank.IDenomUnits); + + /** DenomUnits denom. */ + public denom: string; + + /** DenomUnits exponent. */ + public exponent: number; + + /** DenomUnits aliases. */ + public aliases: string[]; + + /** + * Creates a new DenomUnits instance using the specified properties. + * @param [properties] Properties to set + * @returns DenomUnits instance + */ + public static create(properties?: cosmos.bank.IDenomUnits): cosmos.bank.DenomUnits; + + /** + * Encodes the specified DenomUnits message. Does not implicitly {@link cosmos.bank.DenomUnits.verify|verify} messages. + * @param m DenomUnits message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.bank.IDenomUnits, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DenomUnits message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DenomUnits + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.DenomUnits; + } + + /** Properties of a Metadata. */ + interface IMetadata { + /** Metadata description */ + description?: string | null; + + /** Metadata denomUnits */ + denomUnits?: cosmos.bank.IDenomUnits[] | null; + + /** Metadata base */ + base?: string | null; + + /** Metadata display */ + display?: string | null; + } + + /** Represents a Metadata. */ + class Metadata implements IMetadata { + /** + * Constructs a new Metadata. + * @param [p] Properties to set + */ + constructor(p?: cosmos.bank.IMetadata); + + /** Metadata description. */ + public description: string; + + /** Metadata denomUnits. */ + public denomUnits: cosmos.bank.IDenomUnits[]; + + /** Metadata base. */ + public base: string; + + /** Metadata display. */ + public display: string; + + /** + * Creates a new Metadata instance using the specified properties. + * @param [properties] Properties to set + * @returns Metadata instance + */ + public static create(properties?: cosmos.bank.IMetadata): cosmos.bank.Metadata; + + /** + * Encodes the specified Metadata message. Does not implicitly {@link cosmos.bank.Metadata.verify|verify} messages. + * @param m Metadata message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.bank.IMetadata, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Metadata message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Metadata + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.bank.Metadata; + } } /** Namespace crypto. */ @@ -1592,6 +1970,292 @@ export namespace cosmos { SIGN_MODE_TEXTUAL = 2, SIGN_MODE_LEGACY_AMINO_JSON = 127, } + + /** Properties of a SignatureDescriptors. */ + interface ISignatureDescriptors { + /** SignatureDescriptors signatures */ + signatures?: cosmos.tx.signing.ISignatureDescriptor[] | null; + } + + /** Represents a SignatureDescriptors. */ + class SignatureDescriptors implements ISignatureDescriptors { + /** + * Constructs a new SignatureDescriptors. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.ISignatureDescriptors); + + /** SignatureDescriptors signatures. */ + public signatures: cosmos.tx.signing.ISignatureDescriptor[]; + + /** + * Creates a new SignatureDescriptors instance using the specified properties. + * @param [properties] Properties to set + * @returns SignatureDescriptors instance + */ + public static create( + properties?: cosmos.tx.signing.ISignatureDescriptors, + ): cosmos.tx.signing.SignatureDescriptors; + + /** + * Encodes the specified SignatureDescriptors message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptors.verify|verify} messages. + * @param m SignatureDescriptors message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.ISignatureDescriptors, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a SignatureDescriptors message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignatureDescriptors + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptors; + } + + /** Properties of a SignatureDescriptor. */ + interface ISignatureDescriptor { + /** SignatureDescriptor publicKey */ + publicKey?: cosmos.crypto.IPublicKey | null; + + /** SignatureDescriptor data */ + data?: cosmos.tx.signing.SignatureDescriptor.IData | null; + } + + /** Represents a SignatureDescriptor. */ + class SignatureDescriptor implements ISignatureDescriptor { + /** + * Constructs a new SignatureDescriptor. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.ISignatureDescriptor); + + /** SignatureDescriptor publicKey. */ + public publicKey?: cosmos.crypto.IPublicKey | null; + + /** SignatureDescriptor data. */ + public data?: cosmos.tx.signing.SignatureDescriptor.IData | null; + + /** + * Creates a new SignatureDescriptor instance using the specified properties. + * @param [properties] Properties to set + * @returns SignatureDescriptor instance + */ + public static create( + properties?: cosmos.tx.signing.ISignatureDescriptor, + ): cosmos.tx.signing.SignatureDescriptor; + + /** + * Encodes the specified SignatureDescriptor message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.verify|verify} messages. + * @param m SignatureDescriptor message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.ISignatureDescriptor, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a SignatureDescriptor message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SignatureDescriptor + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor; + } + + namespace SignatureDescriptor { + /** Properties of a Data. */ + interface IData { + /** Data single */ + single?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle | null; + + /** Data multi */ + multi?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti | null; + } + + /** Represents a Data. */ + class Data implements IData { + /** + * Constructs a new Data. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.IData); + + /** Data single. */ + public single?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle | null; + + /** Data multi. */ + public multi?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti | null; + + /** Data sum. */ + public sum?: "single" | "multi"; + + /** + * Creates a new Data instance using the specified properties. + * @param [properties] Properties to set + * @returns Data instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.IData, + ): cosmos.tx.signing.SignatureDescriptor.Data; + + /** + * Encodes the specified Data message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.verify|verify} messages. + * @param m Data message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.IData, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Data message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Data + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data; + } + + namespace Data { + /** Properties of a Single. */ + interface ISingle { + /** Single mode */ + mode?: cosmos.tx.signing.SignMode | null; + + /** Single signature */ + signature?: Uint8Array | null; + } + + /** Represents a Single. */ + class Single implements ISingle { + /** + * Constructs a new Single. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle); + + /** Single mode. */ + public mode: cosmos.tx.signing.SignMode; + + /** Single signature. */ + public signature: Uint8Array; + + /** + * Creates a new Single instance using the specified properties. + * @param [properties] Properties to set + * @returns Single instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.Data.ISingle, + ): cosmos.tx.signing.SignatureDescriptor.Data.Single; + + /** + * Encodes the specified Single message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.Single.verify|verify} messages. + * @param m Single message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.Data.ISingle, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Single message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Single + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data.Single; + } + + /** Properties of a Multi. */ + interface IMulti { + /** Multi bitarray */ + bitarray?: cosmos.crypto.ICompactBitArray | null; + + /** Multi signatures */ + signatures?: cosmos.tx.signing.SignatureDescriptor.IData[] | null; + } + + /** Represents a Multi. */ + class Multi implements IMulti { + /** + * Constructs a new Multi. + * @param [p] Properties to set + */ + constructor(p?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti); + + /** Multi bitarray. */ + public bitarray?: cosmos.crypto.ICompactBitArray | null; + + /** Multi signatures. */ + public signatures: cosmos.tx.signing.SignatureDescriptor.IData[]; + + /** + * Creates a new Multi instance using the specified properties. + * @param [properties] Properties to set + * @returns Multi instance + */ + public static create( + properties?: cosmos.tx.signing.SignatureDescriptor.Data.IMulti, + ): cosmos.tx.signing.SignatureDescriptor.Data.Multi; + + /** + * Encodes the specified Multi message. Does not implicitly {@link cosmos.tx.signing.SignatureDescriptor.Data.Multi.verify|verify} messages. + * @param m Multi message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.tx.signing.SignatureDescriptor.Data.IMulti, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Multi message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Multi + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.tx.signing.SignatureDescriptor.Data.Multi; + } + } + } } } }