4700 lines
163 KiB
TypeScript
4700 lines
163 KiB
TypeScript
import * as $protobuf from "protobufjs";
|
|
/** Namespace cosmos_sdk. */
|
|
export namespace cosmos_sdk {
|
|
/** Namespace x. */
|
|
namespace x {
|
|
/** Namespace bank. */
|
|
namespace bank {
|
|
/** Namespace v1. */
|
|
namespace v1 {
|
|
/** Properties of a MsgSend. */
|
|
interface IMsgSend {
|
|
/** MsgSend fromAddress */
|
|
fromAddress?: Uint8Array | null;
|
|
|
|
/** MsgSend toAddress */
|
|
toAddress?: Uint8Array | null;
|
|
|
|
/** MsgSend amount */
|
|
amount?: cosmos_sdk.v1.ICoin[] | null;
|
|
}
|
|
|
|
/** Represents a MsgSend. */
|
|
class MsgSend implements IMsgSend {
|
|
/**
|
|
* Constructs a new MsgSend.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.x.bank.v1.IMsgSend);
|
|
|
|
/** MsgSend fromAddress. */
|
|
public fromAddress: Uint8Array;
|
|
|
|
/** MsgSend toAddress. */
|
|
public toAddress: Uint8Array;
|
|
|
|
/** MsgSend amount. */
|
|
public amount: cosmos_sdk.v1.ICoin[];
|
|
|
|
/**
|
|
* Creates a new MsgSend instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns MsgSend instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.x.bank.v1.IMsgSend): cosmos_sdk.x.bank.v1.MsgSend;
|
|
|
|
/**
|
|
* Encodes the specified MsgSend message. Does not implicitly {@link cosmos_sdk.x.bank.v1.MsgSend.verify|verify} messages.
|
|
* @param m MsgSend message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.x.bank.v1.IMsgSend, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a MsgSend message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns MsgSend
|
|
* @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_sdk.x.bank.v1.MsgSend;
|
|
}
|
|
|
|
/** Properties of an Input. */
|
|
interface IInput {
|
|
/** Input address */
|
|
address?: Uint8Array | null;
|
|
|
|
/** Input coins */
|
|
coins?: cosmos_sdk.v1.ICoin[] | null;
|
|
}
|
|
|
|
/** Represents an Input. */
|
|
class Input implements IInput {
|
|
/**
|
|
* Constructs a new Input.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.x.bank.v1.IInput);
|
|
|
|
/** Input address. */
|
|
public address: Uint8Array;
|
|
|
|
/** Input coins. */
|
|
public coins: cosmos_sdk.v1.ICoin[];
|
|
|
|
/**
|
|
* Creates a new Input instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Input instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.x.bank.v1.IInput): cosmos_sdk.x.bank.v1.Input;
|
|
|
|
/**
|
|
* Encodes the specified Input message. Does not implicitly {@link cosmos_sdk.x.bank.v1.Input.verify|verify} messages.
|
|
* @param m Input message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.x.bank.v1.IInput, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an Input message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Input
|
|
* @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_sdk.x.bank.v1.Input;
|
|
}
|
|
|
|
/** Properties of an Output. */
|
|
interface IOutput {
|
|
/** Output address */
|
|
address?: Uint8Array | null;
|
|
|
|
/** Output coins */
|
|
coins?: cosmos_sdk.v1.ICoin[] | null;
|
|
}
|
|
|
|
/** Represents an Output. */
|
|
class Output implements IOutput {
|
|
/**
|
|
* Constructs a new Output.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.x.bank.v1.IOutput);
|
|
|
|
/** Output address. */
|
|
public address: Uint8Array;
|
|
|
|
/** Output coins. */
|
|
public coins: cosmos_sdk.v1.ICoin[];
|
|
|
|
/**
|
|
* Creates a new Output instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Output instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.x.bank.v1.IOutput): cosmos_sdk.x.bank.v1.Output;
|
|
|
|
/**
|
|
* Encodes the specified Output message. Does not implicitly {@link cosmos_sdk.x.bank.v1.Output.verify|verify} messages.
|
|
* @param m Output message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.x.bank.v1.IOutput, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an Output message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Output
|
|
* @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_sdk.x.bank.v1.Output;
|
|
}
|
|
|
|
/** Properties of a MsgMultiSend. */
|
|
interface IMsgMultiSend {
|
|
/** MsgMultiSend inputs */
|
|
inputs?: cosmos_sdk.x.bank.v1.IInput[] | null;
|
|
|
|
/** MsgMultiSend outputs */
|
|
outputs?: cosmos_sdk.x.bank.v1.IOutput[] | null;
|
|
}
|
|
|
|
/** Represents a MsgMultiSend. */
|
|
class MsgMultiSend implements IMsgMultiSend {
|
|
/**
|
|
* Constructs a new MsgMultiSend.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.x.bank.v1.IMsgMultiSend);
|
|
|
|
/** MsgMultiSend inputs. */
|
|
public inputs: cosmos_sdk.x.bank.v1.IInput[];
|
|
|
|
/** MsgMultiSend outputs. */
|
|
public outputs: cosmos_sdk.x.bank.v1.IOutput[];
|
|
|
|
/**
|
|
* Creates a new MsgMultiSend instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns MsgMultiSend instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.x.bank.v1.IMsgMultiSend,
|
|
): cosmos_sdk.x.bank.v1.MsgMultiSend;
|
|
|
|
/**
|
|
* Encodes the specified MsgMultiSend message. Does not implicitly {@link cosmos_sdk.x.bank.v1.MsgMultiSend.verify|verify} messages.
|
|
* @param m MsgMultiSend message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.x.bank.v1.IMsgMultiSend, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a MsgMultiSend message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns MsgMultiSend
|
|
* @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_sdk.x.bank.v1.MsgMultiSend;
|
|
}
|
|
|
|
/** Properties of a Supply. */
|
|
interface ISupply {
|
|
/** Supply total */
|
|
total?: cosmos_sdk.v1.ICoin[] | null;
|
|
}
|
|
|
|
/** Represents a Supply. */
|
|
class Supply implements ISupply {
|
|
/**
|
|
* Constructs a new Supply.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.x.bank.v1.ISupply);
|
|
|
|
/** Supply total. */
|
|
public total: cosmos_sdk.v1.ICoin[];
|
|
|
|
/**
|
|
* Creates a new Supply instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Supply instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.x.bank.v1.ISupply): cosmos_sdk.x.bank.v1.Supply;
|
|
|
|
/**
|
|
* Encodes the specified Supply message. Does not implicitly {@link cosmos_sdk.x.bank.v1.Supply.verify|verify} messages.
|
|
* @param m Supply message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.x.bank.v1.ISupply, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Supply message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Supply
|
|
* @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_sdk.x.bank.v1.Supply;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace v1. */
|
|
namespace v1 {
|
|
/** Properties of a Coin. */
|
|
interface ICoin {
|
|
/** Coin denom */
|
|
denom?: string | null;
|
|
|
|
/** Coin amount */
|
|
amount?: string | null;
|
|
}
|
|
|
|
/** Represents a Coin. */
|
|
class Coin implements ICoin {
|
|
/**
|
|
* Constructs a new Coin.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.ICoin);
|
|
|
|
/** Coin denom. */
|
|
public denom: string;
|
|
|
|
/** Coin amount. */
|
|
public amount: string;
|
|
|
|
/**
|
|
* Creates a new Coin instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Coin instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.ICoin): cosmos_sdk.v1.Coin;
|
|
|
|
/**
|
|
* Encodes the specified Coin message. Does not implicitly {@link cosmos_sdk.v1.Coin.verify|verify} messages.
|
|
* @param m Coin message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.ICoin, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Coin message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Coin
|
|
* @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_sdk.v1.Coin;
|
|
}
|
|
|
|
/** Properties of a DecCoin. */
|
|
interface IDecCoin {
|
|
/** DecCoin denom */
|
|
denom?: string | null;
|
|
|
|
/** DecCoin amount */
|
|
amount?: string | null;
|
|
}
|
|
|
|
/** Represents a DecCoin. */
|
|
class DecCoin implements IDecCoin {
|
|
/**
|
|
* Constructs a new DecCoin.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IDecCoin);
|
|
|
|
/** DecCoin denom. */
|
|
public denom: string;
|
|
|
|
/** DecCoin amount. */
|
|
public amount: string;
|
|
|
|
/**
|
|
* Creates a new DecCoin instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns DecCoin instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IDecCoin): cosmos_sdk.v1.DecCoin;
|
|
|
|
/**
|
|
* Encodes the specified DecCoin message. Does not implicitly {@link cosmos_sdk.v1.DecCoin.verify|verify} messages.
|
|
* @param m DecCoin message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IDecCoin, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a DecCoin message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns DecCoin
|
|
* @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_sdk.v1.DecCoin;
|
|
}
|
|
|
|
/** Properties of an IntProto. */
|
|
interface IIntProto {
|
|
/** IntProto int */
|
|
int?: string | null;
|
|
}
|
|
|
|
/** Represents an IntProto. */
|
|
class IntProto implements IIntProto {
|
|
/**
|
|
* Constructs a new IntProto.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IIntProto);
|
|
|
|
/** IntProto int. */
|
|
public int: string;
|
|
|
|
/**
|
|
* Creates a new IntProto instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns IntProto instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IIntProto): cosmos_sdk.v1.IntProto;
|
|
|
|
/**
|
|
* Encodes the specified IntProto message. Does not implicitly {@link cosmos_sdk.v1.IntProto.verify|verify} messages.
|
|
* @param m IntProto message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IIntProto, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an IntProto message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns IntProto
|
|
* @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_sdk.v1.IntProto;
|
|
}
|
|
|
|
/** Properties of a DecProto. */
|
|
interface IDecProto {
|
|
/** DecProto dec */
|
|
dec?: string | null;
|
|
}
|
|
|
|
/** Represents a DecProto. */
|
|
class DecProto implements IDecProto {
|
|
/**
|
|
* Constructs a new DecProto.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IDecProto);
|
|
|
|
/** DecProto dec. */
|
|
public dec: string;
|
|
|
|
/**
|
|
* Creates a new DecProto instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns DecProto instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IDecProto): cosmos_sdk.v1.DecProto;
|
|
|
|
/**
|
|
* Encodes the specified DecProto message. Does not implicitly {@link cosmos_sdk.v1.DecProto.verify|verify} messages.
|
|
* @param m DecProto message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IDecProto, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a DecProto message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns DecProto
|
|
* @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_sdk.v1.DecProto;
|
|
}
|
|
|
|
/** Properties of a ValAddresses. */
|
|
interface IValAddresses {
|
|
/** ValAddresses addresses */
|
|
addresses?: Uint8Array[] | null;
|
|
}
|
|
|
|
/** Represents a ValAddresses. */
|
|
class ValAddresses implements IValAddresses {
|
|
/**
|
|
* Constructs a new ValAddresses.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IValAddresses);
|
|
|
|
/** ValAddresses addresses. */
|
|
public addresses: Uint8Array[];
|
|
|
|
/**
|
|
* Creates a new ValAddresses instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ValAddresses instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IValAddresses): cosmos_sdk.v1.ValAddresses;
|
|
|
|
/**
|
|
* Encodes the specified ValAddresses message. Does not implicitly {@link cosmos_sdk.v1.ValAddresses.verify|verify} messages.
|
|
* @param m ValAddresses message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IValAddresses, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ValAddresses message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ValAddresses
|
|
* @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_sdk.v1.ValAddresses;
|
|
}
|
|
|
|
/** Properties of a GasInfo. */
|
|
interface IGasInfo {
|
|
/** GasInfo gasWanted */
|
|
gasWanted?: number | Long | null;
|
|
|
|
/** GasInfo gasUsed */
|
|
gasUsed?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a GasInfo. */
|
|
class GasInfo implements IGasInfo {
|
|
/**
|
|
* Constructs a new GasInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IGasInfo);
|
|
|
|
/** GasInfo gasWanted. */
|
|
public gasWanted: number | Long;
|
|
|
|
/** GasInfo gasUsed. */
|
|
public gasUsed: number | Long;
|
|
|
|
/**
|
|
* Creates a new GasInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns GasInfo instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IGasInfo): cosmos_sdk.v1.GasInfo;
|
|
|
|
/**
|
|
* Encodes the specified GasInfo message. Does not implicitly {@link cosmos_sdk.v1.GasInfo.verify|verify} messages.
|
|
* @param m GasInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IGasInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a GasInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns GasInfo
|
|
* @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_sdk.v1.GasInfo;
|
|
}
|
|
|
|
/** Properties of a Result. */
|
|
interface IResult {
|
|
/** Result data */
|
|
data?: Uint8Array | null;
|
|
|
|
/** Result log */
|
|
log?: string | null;
|
|
|
|
/** Result events */
|
|
events?: tendermint.abci.types.IEvent[] | null;
|
|
}
|
|
|
|
/** Represents a Result. */
|
|
class Result implements IResult {
|
|
/**
|
|
* Constructs a new Result.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IResult);
|
|
|
|
/** Result data. */
|
|
public data: Uint8Array;
|
|
|
|
/** Result log. */
|
|
public log: string;
|
|
|
|
/** Result events. */
|
|
public events: tendermint.abci.types.IEvent[];
|
|
|
|
/**
|
|
* Creates a new Result instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Result instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IResult): cosmos_sdk.v1.Result;
|
|
|
|
/**
|
|
* Encodes the specified Result message. Does not implicitly {@link cosmos_sdk.v1.Result.verify|verify} messages.
|
|
* @param m Result message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IResult, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Result message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Result
|
|
* @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_sdk.v1.Result;
|
|
}
|
|
|
|
/** Properties of a SimulationResponse. */
|
|
interface ISimulationResponse {
|
|
/** SimulationResponse gasInfo */
|
|
gasInfo?: cosmos_sdk.v1.IGasInfo | null;
|
|
|
|
/** SimulationResponse result */
|
|
result?: cosmos_sdk.v1.IResult | null;
|
|
}
|
|
|
|
/** Represents a SimulationResponse. */
|
|
class SimulationResponse implements ISimulationResponse {
|
|
/**
|
|
* Constructs a new SimulationResponse.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.ISimulationResponse);
|
|
|
|
/** SimulationResponse gasInfo. */
|
|
public gasInfo?: cosmos_sdk.v1.IGasInfo | null;
|
|
|
|
/** SimulationResponse result. */
|
|
public result?: cosmos_sdk.v1.IResult | null;
|
|
|
|
/**
|
|
* Creates a new SimulationResponse instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns SimulationResponse instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.ISimulationResponse): cosmos_sdk.v1.SimulationResponse;
|
|
|
|
/**
|
|
* Encodes the specified SimulationResponse message. Does not implicitly {@link cosmos_sdk.v1.SimulationResponse.verify|verify} messages.
|
|
* @param m SimulationResponse message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.ISimulationResponse, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a SimulationResponse message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns SimulationResponse
|
|
* @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_sdk.v1.SimulationResponse;
|
|
}
|
|
|
|
/** Properties of a MsgData. */
|
|
interface IMsgData {
|
|
/** MsgData msgType */
|
|
msgType?: string | null;
|
|
|
|
/** MsgData data */
|
|
data?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a MsgData. */
|
|
class MsgData implements IMsgData {
|
|
/**
|
|
* Constructs a new MsgData.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.IMsgData);
|
|
|
|
/** MsgData msgType. */
|
|
public msgType: string;
|
|
|
|
/** MsgData data. */
|
|
public data: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new MsgData instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns MsgData instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.IMsgData): cosmos_sdk.v1.MsgData;
|
|
|
|
/**
|
|
* Encodes the specified MsgData message. Does not implicitly {@link cosmos_sdk.v1.MsgData.verify|verify} messages.
|
|
* @param m MsgData message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.IMsgData, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a MsgData message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns MsgData
|
|
* @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_sdk.v1.MsgData;
|
|
}
|
|
|
|
/** Properties of a TxData. */
|
|
interface ITxData {
|
|
/** TxData data */
|
|
data?: cosmos_sdk.v1.IMsgData[] | null;
|
|
}
|
|
|
|
/** Represents a TxData. */
|
|
class TxData implements ITxData {
|
|
/**
|
|
* Constructs a new TxData.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.v1.ITxData);
|
|
|
|
/** TxData data. */
|
|
public data: cosmos_sdk.v1.IMsgData[];
|
|
|
|
/**
|
|
* Creates a new TxData instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns TxData instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.v1.ITxData): cosmos_sdk.v1.TxData;
|
|
|
|
/**
|
|
* Encodes the specified TxData message. Does not implicitly {@link cosmos_sdk.v1.TxData.verify|verify} messages.
|
|
* @param m TxData message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.v1.ITxData, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a TxData message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns TxData
|
|
* @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_sdk.v1.TxData;
|
|
}
|
|
}
|
|
|
|
/** Namespace tx. */
|
|
namespace tx {
|
|
/** Namespace v1. */
|
|
namespace v1 {
|
|
/** Properties of a Tx. */
|
|
interface ITx {
|
|
/** Tx body */
|
|
body?: cosmos_sdk.tx.v1.ITxBody | null;
|
|
|
|
/** Tx authInfo */
|
|
authInfo?: cosmos_sdk.tx.v1.IAuthInfo | null;
|
|
|
|
/** Tx signatures */
|
|
signatures?: Uint8Array[] | null;
|
|
}
|
|
|
|
/** Represents a Tx. */
|
|
class Tx implements ITx {
|
|
/**
|
|
* Constructs a new Tx.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ITx);
|
|
|
|
/** Tx body. */
|
|
public body?: cosmos_sdk.tx.v1.ITxBody | null;
|
|
|
|
/** Tx authInfo. */
|
|
public authInfo?: cosmos_sdk.tx.v1.IAuthInfo | null;
|
|
|
|
/** Tx signatures. */
|
|
public signatures: Uint8Array[];
|
|
|
|
/**
|
|
* Creates a new Tx instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Tx instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.ITx): cosmos_sdk.tx.v1.Tx;
|
|
|
|
/**
|
|
* Encodes the specified Tx message. Does not implicitly {@link cosmos_sdk.tx.v1.Tx.verify|verify} messages.
|
|
* @param m Tx message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.ITx, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Tx message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Tx
|
|
* @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_sdk.tx.v1.Tx;
|
|
}
|
|
|
|
/** Properties of a SignDoc. */
|
|
interface ISignDoc {
|
|
/** SignDoc body */
|
|
body?: cosmos_sdk.tx.v1.ITxBody | null;
|
|
|
|
/** SignDoc authInfo */
|
|
authInfo?: cosmos_sdk.tx.v1.IAuthInfo | null;
|
|
|
|
/** SignDoc chainId */
|
|
chainId?: string | null;
|
|
|
|
/** SignDoc accountNumber */
|
|
accountNumber?: number | Long | null;
|
|
|
|
/** SignDoc accountSequence */
|
|
accountSequence?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a SignDoc. */
|
|
class SignDoc implements ISignDoc {
|
|
/**
|
|
* Constructs a new SignDoc.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ISignDoc);
|
|
|
|
/** SignDoc body. */
|
|
public body?: cosmos_sdk.tx.v1.ITxBody | null;
|
|
|
|
/** SignDoc authInfo. */
|
|
public authInfo?: cosmos_sdk.tx.v1.IAuthInfo | null;
|
|
|
|
/** SignDoc chainId. */
|
|
public chainId: string;
|
|
|
|
/** SignDoc accountNumber. */
|
|
public accountNumber: number | Long;
|
|
|
|
/** SignDoc accountSequence. */
|
|
public accountSequence: number | Long;
|
|
|
|
/**
|
|
* Creates a new SignDoc instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns SignDoc instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.ISignDoc): cosmos_sdk.tx.v1.SignDoc;
|
|
|
|
/**
|
|
* Encodes the specified SignDoc message. Does not implicitly {@link cosmos_sdk.tx.v1.SignDoc.verify|verify} messages.
|
|
* @param m SignDoc message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.ISignDoc, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a SignDoc message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns SignDoc
|
|
* @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_sdk.tx.v1.SignDoc;
|
|
}
|
|
|
|
/** Properties of a TxBody. */
|
|
interface ITxBody {
|
|
/** TxBody messages */
|
|
messages?: google.protobuf.IAny[] | null;
|
|
|
|
/** TxBody memo */
|
|
memo?: string | null;
|
|
|
|
/** TxBody timeoutHeight */
|
|
timeoutHeight?: number | Long | null;
|
|
|
|
/** TxBody extensionOptions */
|
|
extensionOptions?: google.protobuf.IAny[] | null;
|
|
|
|
/** TxBody nonCriticalExtensionOptions */
|
|
nonCriticalExtensionOptions?: google.protobuf.IAny[] | null;
|
|
}
|
|
|
|
/** Represents a TxBody. */
|
|
class TxBody implements ITxBody {
|
|
/**
|
|
* Constructs a new TxBody.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ITxBody);
|
|
|
|
/** TxBody messages. */
|
|
public messages: google.protobuf.IAny[];
|
|
|
|
/** TxBody memo. */
|
|
public memo: string;
|
|
|
|
/** TxBody timeoutHeight. */
|
|
public timeoutHeight: number | Long;
|
|
|
|
/** TxBody extensionOptions. */
|
|
public extensionOptions: google.protobuf.IAny[];
|
|
|
|
/** TxBody nonCriticalExtensionOptions. */
|
|
public nonCriticalExtensionOptions: google.protobuf.IAny[];
|
|
|
|
/**
|
|
* Creates a new TxBody instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns TxBody instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.ITxBody): cosmos_sdk.tx.v1.TxBody;
|
|
|
|
/**
|
|
* Encodes the specified TxBody message. Does not implicitly {@link cosmos_sdk.tx.v1.TxBody.verify|verify} messages.
|
|
* @param m TxBody message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.ITxBody, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a TxBody message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns TxBody
|
|
* @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_sdk.tx.v1.TxBody;
|
|
}
|
|
|
|
/** Properties of an AuthInfo. */
|
|
interface IAuthInfo {
|
|
/** AuthInfo signerInfos */
|
|
signerInfos?: cosmos_sdk.tx.v1.ISignerInfo[] | null;
|
|
|
|
/** AuthInfo fee */
|
|
fee?: cosmos_sdk.tx.v1.IFee | null;
|
|
}
|
|
|
|
/** Represents an AuthInfo. */
|
|
class AuthInfo implements IAuthInfo {
|
|
/**
|
|
* Constructs a new AuthInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.IAuthInfo);
|
|
|
|
/** AuthInfo signerInfos. */
|
|
public signerInfos: cosmos_sdk.tx.v1.ISignerInfo[];
|
|
|
|
/** AuthInfo fee. */
|
|
public fee?: cosmos_sdk.tx.v1.IFee | null;
|
|
|
|
/**
|
|
* Creates a new AuthInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns AuthInfo instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.IAuthInfo): cosmos_sdk.tx.v1.AuthInfo;
|
|
|
|
/**
|
|
* Encodes the specified AuthInfo message. Does not implicitly {@link cosmos_sdk.tx.v1.AuthInfo.verify|verify} messages.
|
|
* @param m AuthInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.IAuthInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an AuthInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns AuthInfo
|
|
* @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_sdk.tx.v1.AuthInfo;
|
|
}
|
|
|
|
/** Properties of a SignerInfo. */
|
|
interface ISignerInfo {
|
|
/** SignerInfo publicKey */
|
|
publicKey?: google.protobuf.IAny | null;
|
|
|
|
/** SignerInfo modeInfo */
|
|
modeInfo?: cosmos_sdk.tx.v1.IModeInfo | null;
|
|
}
|
|
|
|
/** Represents a SignerInfo. */
|
|
class SignerInfo implements ISignerInfo {
|
|
/**
|
|
* Constructs a new SignerInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ISignerInfo);
|
|
|
|
/** SignerInfo publicKey. */
|
|
public publicKey?: google.protobuf.IAny | null;
|
|
|
|
/** SignerInfo modeInfo. */
|
|
public modeInfo?: cosmos_sdk.tx.v1.IModeInfo | null;
|
|
|
|
/**
|
|
* Creates a new SignerInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns SignerInfo instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.ISignerInfo): cosmos_sdk.tx.v1.SignerInfo;
|
|
|
|
/**
|
|
* Encodes the specified SignerInfo message. Does not implicitly {@link cosmos_sdk.tx.v1.SignerInfo.verify|verify} messages.
|
|
* @param m SignerInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.ISignerInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a SignerInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns SignerInfo
|
|
* @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_sdk.tx.v1.SignerInfo;
|
|
}
|
|
|
|
/** Properties of a ModeInfo. */
|
|
interface IModeInfo {
|
|
/** ModeInfo single */
|
|
single?: cosmos_sdk.tx.v1.ModeInfo.ISingle | null;
|
|
|
|
/** ModeInfo multi */
|
|
multi?: cosmos_sdk.tx.v1.ModeInfo.IMulti | null;
|
|
}
|
|
|
|
/** Represents a ModeInfo. */
|
|
class ModeInfo implements IModeInfo {
|
|
/**
|
|
* Constructs a new ModeInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.IModeInfo);
|
|
|
|
/** ModeInfo single. */
|
|
public single?: cosmos_sdk.tx.v1.ModeInfo.ISingle | null;
|
|
|
|
/** ModeInfo multi. */
|
|
public multi?: cosmos_sdk.tx.v1.ModeInfo.IMulti | null;
|
|
|
|
/** ModeInfo sum. */
|
|
public sum?: "single" | "multi";
|
|
|
|
/**
|
|
* Creates a new ModeInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ModeInfo instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.IModeInfo): cosmos_sdk.tx.v1.ModeInfo;
|
|
|
|
/**
|
|
* Encodes the specified ModeInfo message. Does not implicitly {@link cosmos_sdk.tx.v1.ModeInfo.verify|verify} messages.
|
|
* @param m ModeInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.IModeInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ModeInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ModeInfo
|
|
* @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_sdk.tx.v1.ModeInfo;
|
|
}
|
|
|
|
namespace ModeInfo {
|
|
/** Properties of a Single. */
|
|
interface ISingle {
|
|
/** Single mode */
|
|
mode?: cosmos_sdk.tx.signing.v1.SignMode | null;
|
|
}
|
|
|
|
/** Represents a Single. */
|
|
class Single implements ISingle {
|
|
/**
|
|
* Constructs a new Single.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ModeInfo.ISingle);
|
|
|
|
/** Single mode. */
|
|
public mode: cosmos_sdk.tx.signing.v1.SignMode;
|
|
|
|
/**
|
|
* Creates a new Single instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Single instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.tx.v1.ModeInfo.ISingle,
|
|
): cosmos_sdk.tx.v1.ModeInfo.Single;
|
|
|
|
/**
|
|
* Encodes the specified Single message. Does not implicitly {@link cosmos_sdk.tx.v1.ModeInfo.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_sdk.tx.v1.ModeInfo.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_sdk.tx.v1.ModeInfo.Single;
|
|
}
|
|
|
|
/** Properties of a Multi. */
|
|
interface IMulti {
|
|
/** Multi bitarray */
|
|
bitarray?: cosmos_sdk.crypto.v1.ICompactBitArray | null;
|
|
|
|
/** Multi modeInfos */
|
|
modeInfos?: cosmos_sdk.tx.v1.IModeInfo[] | null;
|
|
}
|
|
|
|
/** Represents a Multi. */
|
|
class Multi implements IMulti {
|
|
/**
|
|
* Constructs a new Multi.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.ModeInfo.IMulti);
|
|
|
|
/** Multi bitarray. */
|
|
public bitarray?: cosmos_sdk.crypto.v1.ICompactBitArray | null;
|
|
|
|
/** Multi modeInfos. */
|
|
public modeInfos: cosmos_sdk.tx.v1.IModeInfo[];
|
|
|
|
/**
|
|
* Creates a new Multi instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Multi instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.tx.v1.ModeInfo.IMulti,
|
|
): cosmos_sdk.tx.v1.ModeInfo.Multi;
|
|
|
|
/**
|
|
* Encodes the specified Multi message. Does not implicitly {@link cosmos_sdk.tx.v1.ModeInfo.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_sdk.tx.v1.ModeInfo.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_sdk.tx.v1.ModeInfo.Multi;
|
|
}
|
|
}
|
|
|
|
/** Properties of a Fee. */
|
|
interface IFee {
|
|
/** Fee amount */
|
|
amount?: cosmos_sdk.v1.ICoin[] | null;
|
|
|
|
/** Fee gasLimit */
|
|
gasLimit?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a Fee. */
|
|
class Fee implements IFee {
|
|
/**
|
|
* Constructs a new Fee.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.tx.v1.IFee);
|
|
|
|
/** Fee amount. */
|
|
public amount: cosmos_sdk.v1.ICoin[];
|
|
|
|
/** Fee gasLimit. */
|
|
public gasLimit: number | Long;
|
|
|
|
/**
|
|
* Creates a new Fee instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Fee instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.tx.v1.IFee): cosmos_sdk.tx.v1.Fee;
|
|
|
|
/**
|
|
* Encodes the specified Fee message. Does not implicitly {@link cosmos_sdk.tx.v1.Fee.verify|verify} messages.
|
|
* @param m Fee message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.tx.v1.IFee, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Fee message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Fee
|
|
* @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_sdk.tx.v1.Fee;
|
|
}
|
|
}
|
|
|
|
/** Namespace signing. */
|
|
namespace signing {
|
|
/** Namespace v1. */
|
|
namespace v1 {
|
|
/** SignMode enum. */
|
|
enum SignMode {
|
|
SIGN_MODE_UNSPECIFIED = 0,
|
|
SIGN_MODE_DIRECT = 1,
|
|
SIGN_MODE_TEXTUAL = 2,
|
|
SIGN_MODE_LEGACY_AMINO_JSON = 127,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace crypto. */
|
|
namespace crypto {
|
|
/** Namespace v1. */
|
|
namespace v1 {
|
|
/** Properties of a PublicKey. */
|
|
interface IPublicKey {
|
|
/** PublicKey secp256k1 */
|
|
secp256k1?: Uint8Array | null;
|
|
|
|
/** PublicKey ed25519 */
|
|
ed25519?: Uint8Array | null;
|
|
|
|
/** PublicKey sr25519 */
|
|
sr25519?: Uint8Array | null;
|
|
|
|
/** PublicKey multisig */
|
|
multisig?: cosmos_sdk.crypto.v1.IPubKeyMultisigThreshold | null;
|
|
|
|
/** PublicKey secp256r1 */
|
|
secp256r1?: Uint8Array | null;
|
|
|
|
/** PublicKey anyPubkey */
|
|
anyPubkey?: google.protobuf.IAny | null;
|
|
}
|
|
|
|
/** Represents a PublicKey. */
|
|
class PublicKey implements IPublicKey {
|
|
/**
|
|
* Constructs a new PublicKey.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.crypto.v1.IPublicKey);
|
|
|
|
/** PublicKey secp256k1. */
|
|
public secp256k1: Uint8Array;
|
|
|
|
/** PublicKey ed25519. */
|
|
public ed25519: Uint8Array;
|
|
|
|
/** PublicKey sr25519. */
|
|
public sr25519: Uint8Array;
|
|
|
|
/** PublicKey multisig. */
|
|
public multisig?: cosmos_sdk.crypto.v1.IPubKeyMultisigThreshold | null;
|
|
|
|
/** PublicKey secp256r1. */
|
|
public secp256r1: Uint8Array;
|
|
|
|
/** PublicKey anyPubkey. */
|
|
public anyPubkey?: google.protobuf.IAny | null;
|
|
|
|
/** PublicKey sum. */
|
|
public sum?: "secp256k1" | "ed25519" | "sr25519" | "multisig" | "secp256r1" | "anyPubkey";
|
|
|
|
/**
|
|
* Creates a new PublicKey instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns PublicKey instance
|
|
*/
|
|
public static create(properties?: cosmos_sdk.crypto.v1.IPublicKey): cosmos_sdk.crypto.v1.PublicKey;
|
|
|
|
/**
|
|
* Encodes the specified PublicKey message. Does not implicitly {@link cosmos_sdk.crypto.v1.PublicKey.verify|verify} messages.
|
|
* @param m PublicKey message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.crypto.v1.IPublicKey, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a PublicKey message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns PublicKey
|
|
* @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_sdk.crypto.v1.PublicKey;
|
|
}
|
|
|
|
/** Properties of a PubKeyMultisigThreshold. */
|
|
interface IPubKeyMultisigThreshold {
|
|
/** PubKeyMultisigThreshold threshold */
|
|
threshold?: number | null;
|
|
|
|
/** PubKeyMultisigThreshold publicKeys */
|
|
publicKeys?: cosmos_sdk.crypto.v1.IPublicKey[] | null;
|
|
}
|
|
|
|
/** Represents a PubKeyMultisigThreshold. */
|
|
class PubKeyMultisigThreshold implements IPubKeyMultisigThreshold {
|
|
/**
|
|
* Constructs a new PubKeyMultisigThreshold.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.crypto.v1.IPubKeyMultisigThreshold);
|
|
|
|
/** PubKeyMultisigThreshold threshold. */
|
|
public threshold: number;
|
|
|
|
/** PubKeyMultisigThreshold publicKeys. */
|
|
public publicKeys: cosmos_sdk.crypto.v1.IPublicKey[];
|
|
|
|
/**
|
|
* Creates a new PubKeyMultisigThreshold instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns PubKeyMultisigThreshold instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.crypto.v1.IPubKeyMultisigThreshold,
|
|
): cosmos_sdk.crypto.v1.PubKeyMultisigThreshold;
|
|
|
|
/**
|
|
* Encodes the specified PubKeyMultisigThreshold message. Does not implicitly {@link cosmos_sdk.crypto.v1.PubKeyMultisigThreshold.verify|verify} messages.
|
|
* @param m PubKeyMultisigThreshold message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: cosmos_sdk.crypto.v1.IPubKeyMultisigThreshold,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a PubKeyMultisigThreshold message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns PubKeyMultisigThreshold
|
|
* @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_sdk.crypto.v1.PubKeyMultisigThreshold;
|
|
}
|
|
|
|
/** Properties of a MultiSignature. */
|
|
interface IMultiSignature {
|
|
/** MultiSignature signatures */
|
|
signatures?: Uint8Array[] | null;
|
|
}
|
|
|
|
/** Represents a MultiSignature. */
|
|
class MultiSignature implements IMultiSignature {
|
|
/**
|
|
* Constructs a new MultiSignature.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.crypto.v1.IMultiSignature);
|
|
|
|
/** MultiSignature signatures. */
|
|
public signatures: Uint8Array[];
|
|
|
|
/**
|
|
* Creates a new MultiSignature instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns MultiSignature instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.crypto.v1.IMultiSignature,
|
|
): cosmos_sdk.crypto.v1.MultiSignature;
|
|
|
|
/**
|
|
* Encodes the specified MultiSignature message. Does not implicitly {@link cosmos_sdk.crypto.v1.MultiSignature.verify|verify} messages.
|
|
* @param m MultiSignature message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: cosmos_sdk.crypto.v1.IMultiSignature, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a MultiSignature message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns MultiSignature
|
|
* @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_sdk.crypto.v1.MultiSignature;
|
|
}
|
|
|
|
/** Properties of a CompactBitArray. */
|
|
interface ICompactBitArray {
|
|
/** CompactBitArray extraBitsStored */
|
|
extraBitsStored?: number | null;
|
|
|
|
/** CompactBitArray elems */
|
|
elems?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a CompactBitArray. */
|
|
class CompactBitArray implements ICompactBitArray {
|
|
/**
|
|
* Constructs a new CompactBitArray.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: cosmos_sdk.crypto.v1.ICompactBitArray);
|
|
|
|
/** CompactBitArray extraBitsStored. */
|
|
public extraBitsStored: number;
|
|
|
|
/** CompactBitArray elems. */
|
|
public elems: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new CompactBitArray instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns CompactBitArray instance
|
|
*/
|
|
public static create(
|
|
properties?: cosmos_sdk.crypto.v1.ICompactBitArray,
|
|
): cosmos_sdk.crypto.v1.CompactBitArray;
|
|
|
|
/**
|
|
* Encodes the specified CompactBitArray message. Does not implicitly {@link cosmos_sdk.crypto.v1.CompactBitArray.verify|verify} messages.
|
|
* @param m CompactBitArray message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: cosmos_sdk.crypto.v1.ICompactBitArray,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a CompactBitArray message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns CompactBitArray
|
|
* @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_sdk.crypto.v1.CompactBitArray;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace tendermint. */
|
|
export namespace tendermint {
|
|
/** Namespace abci. */
|
|
namespace abci {
|
|
/** Namespace types. */
|
|
namespace types {
|
|
/** Properties of a Request. */
|
|
interface IRequest {
|
|
/** Request echo */
|
|
echo?: tendermint.abci.types.IRequestEcho | null;
|
|
|
|
/** Request flush */
|
|
flush?: tendermint.abci.types.IRequestFlush | null;
|
|
|
|
/** Request info */
|
|
info?: tendermint.abci.types.IRequestInfo | null;
|
|
|
|
/** Request setOption */
|
|
setOption?: tendermint.abci.types.IRequestSetOption | null;
|
|
|
|
/** Request initChain */
|
|
initChain?: tendermint.abci.types.IRequestInitChain | null;
|
|
|
|
/** Request query */
|
|
query?: tendermint.abci.types.IRequestQuery | null;
|
|
|
|
/** Request beginBlock */
|
|
beginBlock?: tendermint.abci.types.IRequestBeginBlock | null;
|
|
|
|
/** Request checkTx */
|
|
checkTx?: tendermint.abci.types.IRequestCheckTx | null;
|
|
|
|
/** Request deliverTx */
|
|
deliverTx?: tendermint.abci.types.IRequestDeliverTx | null;
|
|
|
|
/** Request endBlock */
|
|
endBlock?: tendermint.abci.types.IRequestEndBlock | null;
|
|
|
|
/** Request commit */
|
|
commit?: tendermint.abci.types.IRequestCommit | null;
|
|
}
|
|
|
|
/** Represents a Request. */
|
|
class Request implements IRequest {
|
|
/**
|
|
* Constructs a new Request.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequest);
|
|
|
|
/** Request echo. */
|
|
public echo?: tendermint.abci.types.IRequestEcho | null;
|
|
|
|
/** Request flush. */
|
|
public flush?: tendermint.abci.types.IRequestFlush | null;
|
|
|
|
/** Request info. */
|
|
public info?: tendermint.abci.types.IRequestInfo | null;
|
|
|
|
/** Request setOption. */
|
|
public setOption?: tendermint.abci.types.IRequestSetOption | null;
|
|
|
|
/** Request initChain. */
|
|
public initChain?: tendermint.abci.types.IRequestInitChain | null;
|
|
|
|
/** Request query. */
|
|
public query?: tendermint.abci.types.IRequestQuery | null;
|
|
|
|
/** Request beginBlock. */
|
|
public beginBlock?: tendermint.abci.types.IRequestBeginBlock | null;
|
|
|
|
/** Request checkTx. */
|
|
public checkTx?: tendermint.abci.types.IRequestCheckTx | null;
|
|
|
|
/** Request deliverTx. */
|
|
public deliverTx?: tendermint.abci.types.IRequestDeliverTx | null;
|
|
|
|
/** Request endBlock. */
|
|
public endBlock?: tendermint.abci.types.IRequestEndBlock | null;
|
|
|
|
/** Request commit. */
|
|
public commit?: tendermint.abci.types.IRequestCommit | null;
|
|
|
|
/** Request value. */
|
|
public value?:
|
|
| "echo"
|
|
| "flush"
|
|
| "info"
|
|
| "setOption"
|
|
| "initChain"
|
|
| "query"
|
|
| "beginBlock"
|
|
| "checkTx"
|
|
| "deliverTx"
|
|
| "endBlock"
|
|
| "commit";
|
|
|
|
/**
|
|
* Creates a new Request instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Request instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IRequest): tendermint.abci.types.Request;
|
|
|
|
/**
|
|
* Encodes the specified Request message. Does not implicitly {@link tendermint.abci.types.Request.verify|verify} messages.
|
|
* @param m Request message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequest, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Request message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Request
|
|
* @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): tendermint.abci.types.Request;
|
|
}
|
|
|
|
/** Properties of a RequestEcho. */
|
|
interface IRequestEcho {
|
|
/** RequestEcho message */
|
|
message?: string | null;
|
|
}
|
|
|
|
/** Represents a RequestEcho. */
|
|
class RequestEcho implements IRequestEcho {
|
|
/**
|
|
* Constructs a new RequestEcho.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestEcho);
|
|
|
|
/** RequestEcho message. */
|
|
public message: string;
|
|
|
|
/**
|
|
* Creates a new RequestEcho instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestEcho instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestEcho,
|
|
): tendermint.abci.types.RequestEcho;
|
|
|
|
/**
|
|
* Encodes the specified RequestEcho message. Does not implicitly {@link tendermint.abci.types.RequestEcho.verify|verify} messages.
|
|
* @param m RequestEcho message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequestEcho, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestEcho message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestEcho
|
|
* @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): tendermint.abci.types.RequestEcho;
|
|
}
|
|
|
|
/** Properties of a RequestFlush. */
|
|
interface IRequestFlush {}
|
|
|
|
/** Represents a RequestFlush. */
|
|
class RequestFlush implements IRequestFlush {
|
|
/**
|
|
* Constructs a new RequestFlush.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestFlush);
|
|
|
|
/**
|
|
* Creates a new RequestFlush instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestFlush instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestFlush,
|
|
): tendermint.abci.types.RequestFlush;
|
|
|
|
/**
|
|
* Encodes the specified RequestFlush message. Does not implicitly {@link tendermint.abci.types.RequestFlush.verify|verify} messages.
|
|
* @param m RequestFlush message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequestFlush, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestFlush message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestFlush
|
|
* @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,
|
|
): tendermint.abci.types.RequestFlush;
|
|
}
|
|
|
|
/** Properties of a RequestInfo. */
|
|
interface IRequestInfo {
|
|
/** RequestInfo version */
|
|
version?: string | null;
|
|
|
|
/** RequestInfo blockVersion */
|
|
blockVersion?: number | Long | null;
|
|
|
|
/** RequestInfo p2pVersion */
|
|
p2pVersion?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a RequestInfo. */
|
|
class RequestInfo implements IRequestInfo {
|
|
/**
|
|
* Constructs a new RequestInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestInfo);
|
|
|
|
/** RequestInfo version. */
|
|
public version: string;
|
|
|
|
/** RequestInfo blockVersion. */
|
|
public blockVersion: number | Long;
|
|
|
|
/** RequestInfo p2pVersion. */
|
|
public p2pVersion: number | Long;
|
|
|
|
/**
|
|
* Creates a new RequestInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestInfo instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestInfo,
|
|
): tendermint.abci.types.RequestInfo;
|
|
|
|
/**
|
|
* Encodes the specified RequestInfo message. Does not implicitly {@link tendermint.abci.types.RequestInfo.verify|verify} messages.
|
|
* @param m RequestInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequestInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestInfo
|
|
* @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): tendermint.abci.types.RequestInfo;
|
|
}
|
|
|
|
/** Properties of a RequestSetOption. */
|
|
interface IRequestSetOption {
|
|
/** RequestSetOption key */
|
|
key?: string | null;
|
|
|
|
/** RequestSetOption value */
|
|
value?: string | null;
|
|
}
|
|
|
|
/** Represents a RequestSetOption. */
|
|
class RequestSetOption implements IRequestSetOption {
|
|
/**
|
|
* Constructs a new RequestSetOption.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestSetOption);
|
|
|
|
/** RequestSetOption key. */
|
|
public key: string;
|
|
|
|
/** RequestSetOption value. */
|
|
public value: string;
|
|
|
|
/**
|
|
* Creates a new RequestSetOption instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestSetOption instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestSetOption,
|
|
): tendermint.abci.types.RequestSetOption;
|
|
|
|
/**
|
|
* Encodes the specified RequestSetOption message. Does not implicitly {@link tendermint.abci.types.RequestSetOption.verify|verify} messages.
|
|
* @param m RequestSetOption message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestSetOption,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestSetOption message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestSetOption
|
|
* @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,
|
|
): tendermint.abci.types.RequestSetOption;
|
|
}
|
|
|
|
/** Properties of a RequestInitChain. */
|
|
interface IRequestInitChain {
|
|
/** RequestInitChain time */
|
|
time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** RequestInitChain chainId */
|
|
chainId?: string | null;
|
|
|
|
/** RequestInitChain consensusParams */
|
|
consensusParams?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** RequestInitChain validators */
|
|
validators?: tendermint.abci.types.IValidatorUpdate[] | null;
|
|
|
|
/** RequestInitChain appStateBytes */
|
|
appStateBytes?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a RequestInitChain. */
|
|
class RequestInitChain implements IRequestInitChain {
|
|
/**
|
|
* Constructs a new RequestInitChain.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestInitChain);
|
|
|
|
/** RequestInitChain time. */
|
|
public time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** RequestInitChain chainId. */
|
|
public chainId: string;
|
|
|
|
/** RequestInitChain consensusParams. */
|
|
public consensusParams?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** RequestInitChain validators. */
|
|
public validators: tendermint.abci.types.IValidatorUpdate[];
|
|
|
|
/** RequestInitChain appStateBytes. */
|
|
public appStateBytes: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new RequestInitChain instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestInitChain instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestInitChain,
|
|
): tendermint.abci.types.RequestInitChain;
|
|
|
|
/**
|
|
* Encodes the specified RequestInitChain message. Does not implicitly {@link tendermint.abci.types.RequestInitChain.verify|verify} messages.
|
|
* @param m RequestInitChain message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestInitChain,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestInitChain message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestInitChain
|
|
* @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,
|
|
): tendermint.abci.types.RequestInitChain;
|
|
}
|
|
|
|
/** Properties of a RequestQuery. */
|
|
interface IRequestQuery {
|
|
/** RequestQuery data */
|
|
data?: Uint8Array | null;
|
|
|
|
/** RequestQuery path */
|
|
path?: string | null;
|
|
|
|
/** RequestQuery height */
|
|
height?: number | Long | null;
|
|
|
|
/** RequestQuery prove */
|
|
prove?: boolean | null;
|
|
}
|
|
|
|
/** Represents a RequestQuery. */
|
|
class RequestQuery implements IRequestQuery {
|
|
/**
|
|
* Constructs a new RequestQuery.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestQuery);
|
|
|
|
/** RequestQuery data. */
|
|
public data: Uint8Array;
|
|
|
|
/** RequestQuery path. */
|
|
public path: string;
|
|
|
|
/** RequestQuery height. */
|
|
public height: number | Long;
|
|
|
|
/** RequestQuery prove. */
|
|
public prove: boolean;
|
|
|
|
/**
|
|
* Creates a new RequestQuery instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestQuery instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestQuery,
|
|
): tendermint.abci.types.RequestQuery;
|
|
|
|
/**
|
|
* Encodes the specified RequestQuery message. Does not implicitly {@link tendermint.abci.types.RequestQuery.verify|verify} messages.
|
|
* @param m RequestQuery message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequestQuery, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestQuery message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestQuery
|
|
* @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,
|
|
): tendermint.abci.types.RequestQuery;
|
|
}
|
|
|
|
/** Properties of a RequestBeginBlock. */
|
|
interface IRequestBeginBlock {
|
|
/** RequestBeginBlock hash */
|
|
hash?: Uint8Array | null;
|
|
|
|
/** RequestBeginBlock header */
|
|
header?: tendermint.abci.types.IHeader | null;
|
|
|
|
/** RequestBeginBlock lastCommitInfo */
|
|
lastCommitInfo?: tendermint.abci.types.ILastCommitInfo | null;
|
|
|
|
/** RequestBeginBlock byzantineValidators */
|
|
byzantineValidators?: tendermint.abci.types.IEvidence[] | null;
|
|
}
|
|
|
|
/** Represents a RequestBeginBlock. */
|
|
class RequestBeginBlock implements IRequestBeginBlock {
|
|
/**
|
|
* Constructs a new RequestBeginBlock.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestBeginBlock);
|
|
|
|
/** RequestBeginBlock hash. */
|
|
public hash: Uint8Array;
|
|
|
|
/** RequestBeginBlock header. */
|
|
public header?: tendermint.abci.types.IHeader | null;
|
|
|
|
/** RequestBeginBlock lastCommitInfo. */
|
|
public lastCommitInfo?: tendermint.abci.types.ILastCommitInfo | null;
|
|
|
|
/** RequestBeginBlock byzantineValidators. */
|
|
public byzantineValidators: tendermint.abci.types.IEvidence[];
|
|
|
|
/**
|
|
* Creates a new RequestBeginBlock instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestBeginBlock instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestBeginBlock,
|
|
): tendermint.abci.types.RequestBeginBlock;
|
|
|
|
/**
|
|
* Encodes the specified RequestBeginBlock message. Does not implicitly {@link tendermint.abci.types.RequestBeginBlock.verify|verify} messages.
|
|
* @param m RequestBeginBlock message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestBeginBlock,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestBeginBlock message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestBeginBlock
|
|
* @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,
|
|
): tendermint.abci.types.RequestBeginBlock;
|
|
}
|
|
|
|
/** CheckTxType enum. */
|
|
enum CheckTxType {
|
|
New = 0,
|
|
Recheck = 1,
|
|
}
|
|
|
|
/** Properties of a RequestCheckTx. */
|
|
interface IRequestCheckTx {
|
|
/** RequestCheckTx tx */
|
|
tx?: Uint8Array | null;
|
|
|
|
/** RequestCheckTx type */
|
|
type?: tendermint.abci.types.CheckTxType | null;
|
|
}
|
|
|
|
/** Represents a RequestCheckTx. */
|
|
class RequestCheckTx implements IRequestCheckTx {
|
|
/**
|
|
* Constructs a new RequestCheckTx.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestCheckTx);
|
|
|
|
/** RequestCheckTx tx. */
|
|
public tx: Uint8Array;
|
|
|
|
/** RequestCheckTx type. */
|
|
public type: tendermint.abci.types.CheckTxType;
|
|
|
|
/**
|
|
* Creates a new RequestCheckTx instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestCheckTx instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestCheckTx,
|
|
): tendermint.abci.types.RequestCheckTx;
|
|
|
|
/**
|
|
* Encodes the specified RequestCheckTx message. Does not implicitly {@link tendermint.abci.types.RequestCheckTx.verify|verify} messages.
|
|
* @param m RequestCheckTx message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestCheckTx,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestCheckTx message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestCheckTx
|
|
* @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,
|
|
): tendermint.abci.types.RequestCheckTx;
|
|
}
|
|
|
|
/** Properties of a RequestDeliverTx. */
|
|
interface IRequestDeliverTx {
|
|
/** RequestDeliverTx tx */
|
|
tx?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a RequestDeliverTx. */
|
|
class RequestDeliverTx implements IRequestDeliverTx {
|
|
/**
|
|
* Constructs a new RequestDeliverTx.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestDeliverTx);
|
|
|
|
/** RequestDeliverTx tx. */
|
|
public tx: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new RequestDeliverTx instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestDeliverTx instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestDeliverTx,
|
|
): tendermint.abci.types.RequestDeliverTx;
|
|
|
|
/**
|
|
* Encodes the specified RequestDeliverTx message. Does not implicitly {@link tendermint.abci.types.RequestDeliverTx.verify|verify} messages.
|
|
* @param m RequestDeliverTx message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestDeliverTx,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestDeliverTx message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestDeliverTx
|
|
* @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,
|
|
): tendermint.abci.types.RequestDeliverTx;
|
|
}
|
|
|
|
/** Properties of a RequestEndBlock. */
|
|
interface IRequestEndBlock {
|
|
/** RequestEndBlock height */
|
|
height?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a RequestEndBlock. */
|
|
class RequestEndBlock implements IRequestEndBlock {
|
|
/**
|
|
* Constructs a new RequestEndBlock.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestEndBlock);
|
|
|
|
/** RequestEndBlock height. */
|
|
public height: number | Long;
|
|
|
|
/**
|
|
* Creates a new RequestEndBlock instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestEndBlock instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestEndBlock,
|
|
): tendermint.abci.types.RequestEndBlock;
|
|
|
|
/**
|
|
* Encodes the specified RequestEndBlock message. Does not implicitly {@link tendermint.abci.types.RequestEndBlock.verify|verify} messages.
|
|
* @param m RequestEndBlock message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IRequestEndBlock,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestEndBlock message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestEndBlock
|
|
* @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,
|
|
): tendermint.abci.types.RequestEndBlock;
|
|
}
|
|
|
|
/** Properties of a RequestCommit. */
|
|
interface IRequestCommit {}
|
|
|
|
/** Represents a RequestCommit. */
|
|
class RequestCommit implements IRequestCommit {
|
|
/**
|
|
* Constructs a new RequestCommit.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IRequestCommit);
|
|
|
|
/**
|
|
* Creates a new RequestCommit instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns RequestCommit instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IRequestCommit,
|
|
): tendermint.abci.types.RequestCommit;
|
|
|
|
/**
|
|
* Encodes the specified RequestCommit message. Does not implicitly {@link tendermint.abci.types.RequestCommit.verify|verify} messages.
|
|
* @param m RequestCommit message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IRequestCommit, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a RequestCommit message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns RequestCommit
|
|
* @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,
|
|
): tendermint.abci.types.RequestCommit;
|
|
}
|
|
|
|
/** Properties of a Response. */
|
|
interface IResponse {
|
|
/** Response exception */
|
|
exception?: tendermint.abci.types.IResponseException | null;
|
|
|
|
/** Response echo */
|
|
echo?: tendermint.abci.types.IResponseEcho | null;
|
|
|
|
/** Response flush */
|
|
flush?: tendermint.abci.types.IResponseFlush | null;
|
|
|
|
/** Response info */
|
|
info?: tendermint.abci.types.IResponseInfo | null;
|
|
|
|
/** Response setOption */
|
|
setOption?: tendermint.abci.types.IResponseSetOption | null;
|
|
|
|
/** Response initChain */
|
|
initChain?: tendermint.abci.types.IResponseInitChain | null;
|
|
|
|
/** Response query */
|
|
query?: tendermint.abci.types.IResponseQuery | null;
|
|
|
|
/** Response beginBlock */
|
|
beginBlock?: tendermint.abci.types.IResponseBeginBlock | null;
|
|
|
|
/** Response checkTx */
|
|
checkTx?: tendermint.abci.types.IResponseCheckTx | null;
|
|
|
|
/** Response deliverTx */
|
|
deliverTx?: tendermint.abci.types.IResponseDeliverTx | null;
|
|
|
|
/** Response endBlock */
|
|
endBlock?: tendermint.abci.types.IResponseEndBlock | null;
|
|
|
|
/** Response commit */
|
|
commit?: tendermint.abci.types.IResponseCommit | null;
|
|
}
|
|
|
|
/** Represents a Response. */
|
|
class Response implements IResponse {
|
|
/**
|
|
* Constructs a new Response.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponse);
|
|
|
|
/** Response exception. */
|
|
public exception?: tendermint.abci.types.IResponseException | null;
|
|
|
|
/** Response echo. */
|
|
public echo?: tendermint.abci.types.IResponseEcho | null;
|
|
|
|
/** Response flush. */
|
|
public flush?: tendermint.abci.types.IResponseFlush | null;
|
|
|
|
/** Response info. */
|
|
public info?: tendermint.abci.types.IResponseInfo | null;
|
|
|
|
/** Response setOption. */
|
|
public setOption?: tendermint.abci.types.IResponseSetOption | null;
|
|
|
|
/** Response initChain. */
|
|
public initChain?: tendermint.abci.types.IResponseInitChain | null;
|
|
|
|
/** Response query. */
|
|
public query?: tendermint.abci.types.IResponseQuery | null;
|
|
|
|
/** Response beginBlock. */
|
|
public beginBlock?: tendermint.abci.types.IResponseBeginBlock | null;
|
|
|
|
/** Response checkTx. */
|
|
public checkTx?: tendermint.abci.types.IResponseCheckTx | null;
|
|
|
|
/** Response deliverTx. */
|
|
public deliverTx?: tendermint.abci.types.IResponseDeliverTx | null;
|
|
|
|
/** Response endBlock. */
|
|
public endBlock?: tendermint.abci.types.IResponseEndBlock | null;
|
|
|
|
/** Response commit. */
|
|
public commit?: tendermint.abci.types.IResponseCommit | null;
|
|
|
|
/** Response value. */
|
|
public value?:
|
|
| "exception"
|
|
| "echo"
|
|
| "flush"
|
|
| "info"
|
|
| "setOption"
|
|
| "initChain"
|
|
| "query"
|
|
| "beginBlock"
|
|
| "checkTx"
|
|
| "deliverTx"
|
|
| "endBlock"
|
|
| "commit";
|
|
|
|
/**
|
|
* Creates a new Response instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Response instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IResponse): tendermint.abci.types.Response;
|
|
|
|
/**
|
|
* Encodes the specified Response message. Does not implicitly {@link tendermint.abci.types.Response.verify|verify} messages.
|
|
* @param m Response message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IResponse, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Response message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Response
|
|
* @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): tendermint.abci.types.Response;
|
|
}
|
|
|
|
/** Properties of a ResponseException. */
|
|
interface IResponseException {
|
|
/** ResponseException error */
|
|
error?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseException. */
|
|
class ResponseException implements IResponseException {
|
|
/**
|
|
* Constructs a new ResponseException.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseException);
|
|
|
|
/** ResponseException error. */
|
|
public error: string;
|
|
|
|
/**
|
|
* Creates a new ResponseException instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseException instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseException,
|
|
): tendermint.abci.types.ResponseException;
|
|
|
|
/**
|
|
* Encodes the specified ResponseException message. Does not implicitly {@link tendermint.abci.types.ResponseException.verify|verify} messages.
|
|
* @param m ResponseException message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseException,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseException message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseException
|
|
* @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,
|
|
): tendermint.abci.types.ResponseException;
|
|
}
|
|
|
|
/** Properties of a ResponseEcho. */
|
|
interface IResponseEcho {
|
|
/** ResponseEcho message */
|
|
message?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseEcho. */
|
|
class ResponseEcho implements IResponseEcho {
|
|
/**
|
|
* Constructs a new ResponseEcho.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseEcho);
|
|
|
|
/** ResponseEcho message. */
|
|
public message: string;
|
|
|
|
/**
|
|
* Creates a new ResponseEcho instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseEcho instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseEcho,
|
|
): tendermint.abci.types.ResponseEcho;
|
|
|
|
/**
|
|
* Encodes the specified ResponseEcho message. Does not implicitly {@link tendermint.abci.types.ResponseEcho.verify|verify} messages.
|
|
* @param m ResponseEcho message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IResponseEcho, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseEcho message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseEcho
|
|
* @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,
|
|
): tendermint.abci.types.ResponseEcho;
|
|
}
|
|
|
|
/** Properties of a ResponseFlush. */
|
|
interface IResponseFlush {}
|
|
|
|
/** Represents a ResponseFlush. */
|
|
class ResponseFlush implements IResponseFlush {
|
|
/**
|
|
* Constructs a new ResponseFlush.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseFlush);
|
|
|
|
/**
|
|
* Creates a new ResponseFlush instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseFlush instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseFlush,
|
|
): tendermint.abci.types.ResponseFlush;
|
|
|
|
/**
|
|
* Encodes the specified ResponseFlush message. Does not implicitly {@link tendermint.abci.types.ResponseFlush.verify|verify} messages.
|
|
* @param m ResponseFlush message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IResponseFlush, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseFlush message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseFlush
|
|
* @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,
|
|
): tendermint.abci.types.ResponseFlush;
|
|
}
|
|
|
|
/** Properties of a ResponseInfo. */
|
|
interface IResponseInfo {
|
|
/** ResponseInfo data */
|
|
data?: string | null;
|
|
|
|
/** ResponseInfo version */
|
|
version?: string | null;
|
|
|
|
/** ResponseInfo appVersion */
|
|
appVersion?: number | Long | null;
|
|
|
|
/** ResponseInfo lastBlockHeight */
|
|
lastBlockHeight?: number | Long | null;
|
|
|
|
/** ResponseInfo lastBlockAppHash */
|
|
lastBlockAppHash?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a ResponseInfo. */
|
|
class ResponseInfo implements IResponseInfo {
|
|
/**
|
|
* Constructs a new ResponseInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseInfo);
|
|
|
|
/** ResponseInfo data. */
|
|
public data: string;
|
|
|
|
/** ResponseInfo version. */
|
|
public version: string;
|
|
|
|
/** ResponseInfo appVersion. */
|
|
public appVersion: number | Long;
|
|
|
|
/** ResponseInfo lastBlockHeight. */
|
|
public lastBlockHeight: number | Long;
|
|
|
|
/** ResponseInfo lastBlockAppHash. */
|
|
public lastBlockAppHash: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new ResponseInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseInfo instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseInfo,
|
|
): tendermint.abci.types.ResponseInfo;
|
|
|
|
/**
|
|
* Encodes the specified ResponseInfo message. Does not implicitly {@link tendermint.abci.types.ResponseInfo.verify|verify} messages.
|
|
* @param m ResponseInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IResponseInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseInfo
|
|
* @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,
|
|
): tendermint.abci.types.ResponseInfo;
|
|
}
|
|
|
|
/** Properties of a ResponseSetOption. */
|
|
interface IResponseSetOption {
|
|
/** ResponseSetOption code */
|
|
code?: number | null;
|
|
|
|
/** ResponseSetOption log */
|
|
log?: string | null;
|
|
|
|
/** ResponseSetOption info */
|
|
info?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseSetOption. */
|
|
class ResponseSetOption implements IResponseSetOption {
|
|
/**
|
|
* Constructs a new ResponseSetOption.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseSetOption);
|
|
|
|
/** ResponseSetOption code. */
|
|
public code: number;
|
|
|
|
/** ResponseSetOption log. */
|
|
public log: string;
|
|
|
|
/** ResponseSetOption info. */
|
|
public info: string;
|
|
|
|
/**
|
|
* Creates a new ResponseSetOption instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseSetOption instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseSetOption,
|
|
): tendermint.abci.types.ResponseSetOption;
|
|
|
|
/**
|
|
* Encodes the specified ResponseSetOption message. Does not implicitly {@link tendermint.abci.types.ResponseSetOption.verify|verify} messages.
|
|
* @param m ResponseSetOption message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseSetOption,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseSetOption message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseSetOption
|
|
* @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,
|
|
): tendermint.abci.types.ResponseSetOption;
|
|
}
|
|
|
|
/** Properties of a ResponseInitChain. */
|
|
interface IResponseInitChain {
|
|
/** ResponseInitChain consensusParams */
|
|
consensusParams?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** ResponseInitChain validators */
|
|
validators?: tendermint.abci.types.IValidatorUpdate[] | null;
|
|
}
|
|
|
|
/** Represents a ResponseInitChain. */
|
|
class ResponseInitChain implements IResponseInitChain {
|
|
/**
|
|
* Constructs a new ResponseInitChain.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseInitChain);
|
|
|
|
/** ResponseInitChain consensusParams. */
|
|
public consensusParams?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** ResponseInitChain validators. */
|
|
public validators: tendermint.abci.types.IValidatorUpdate[];
|
|
|
|
/**
|
|
* Creates a new ResponseInitChain instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseInitChain instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseInitChain,
|
|
): tendermint.abci.types.ResponseInitChain;
|
|
|
|
/**
|
|
* Encodes the specified ResponseInitChain message. Does not implicitly {@link tendermint.abci.types.ResponseInitChain.verify|verify} messages.
|
|
* @param m ResponseInitChain message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseInitChain,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseInitChain message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseInitChain
|
|
* @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,
|
|
): tendermint.abci.types.ResponseInitChain;
|
|
}
|
|
|
|
/** Properties of a ResponseQuery. */
|
|
interface IResponseQuery {
|
|
/** ResponseQuery code */
|
|
code?: number | null;
|
|
|
|
/** ResponseQuery log */
|
|
log?: string | null;
|
|
|
|
/** ResponseQuery info */
|
|
info?: string | null;
|
|
|
|
/** ResponseQuery index */
|
|
index?: number | Long | null;
|
|
|
|
/** ResponseQuery key */
|
|
key?: Uint8Array | null;
|
|
|
|
/** ResponseQuery value */
|
|
value?: Uint8Array | null;
|
|
|
|
/** ResponseQuery proof */
|
|
proof?: tendermint.crypto.merkle.IProof | null;
|
|
|
|
/** ResponseQuery height */
|
|
height?: number | Long | null;
|
|
|
|
/** ResponseQuery codespace */
|
|
codespace?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseQuery. */
|
|
class ResponseQuery implements IResponseQuery {
|
|
/**
|
|
* Constructs a new ResponseQuery.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseQuery);
|
|
|
|
/** ResponseQuery code. */
|
|
public code: number;
|
|
|
|
/** ResponseQuery log. */
|
|
public log: string;
|
|
|
|
/** ResponseQuery info. */
|
|
public info: string;
|
|
|
|
/** ResponseQuery index. */
|
|
public index: number | Long;
|
|
|
|
/** ResponseQuery key. */
|
|
public key: Uint8Array;
|
|
|
|
/** ResponseQuery value. */
|
|
public value: Uint8Array;
|
|
|
|
/** ResponseQuery proof. */
|
|
public proof?: tendermint.crypto.merkle.IProof | null;
|
|
|
|
/** ResponseQuery height. */
|
|
public height: number | Long;
|
|
|
|
/** ResponseQuery codespace. */
|
|
public codespace: string;
|
|
|
|
/**
|
|
* Creates a new ResponseQuery instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseQuery instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseQuery,
|
|
): tendermint.abci.types.ResponseQuery;
|
|
|
|
/**
|
|
* Encodes the specified ResponseQuery message. Does not implicitly {@link tendermint.abci.types.ResponseQuery.verify|verify} messages.
|
|
* @param m ResponseQuery message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IResponseQuery, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseQuery message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseQuery
|
|
* @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,
|
|
): tendermint.abci.types.ResponseQuery;
|
|
}
|
|
|
|
/** Properties of a ResponseBeginBlock. */
|
|
interface IResponseBeginBlock {
|
|
/** ResponseBeginBlock events */
|
|
events?: tendermint.abci.types.IEvent[] | null;
|
|
}
|
|
|
|
/** Represents a ResponseBeginBlock. */
|
|
class ResponseBeginBlock implements IResponseBeginBlock {
|
|
/**
|
|
* Constructs a new ResponseBeginBlock.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseBeginBlock);
|
|
|
|
/** ResponseBeginBlock events. */
|
|
public events: tendermint.abci.types.IEvent[];
|
|
|
|
/**
|
|
* Creates a new ResponseBeginBlock instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseBeginBlock instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseBeginBlock,
|
|
): tendermint.abci.types.ResponseBeginBlock;
|
|
|
|
/**
|
|
* Encodes the specified ResponseBeginBlock message. Does not implicitly {@link tendermint.abci.types.ResponseBeginBlock.verify|verify} messages.
|
|
* @param m ResponseBeginBlock message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseBeginBlock,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseBeginBlock message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseBeginBlock
|
|
* @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,
|
|
): tendermint.abci.types.ResponseBeginBlock;
|
|
}
|
|
|
|
/** Properties of a ResponseCheckTx. */
|
|
interface IResponseCheckTx {
|
|
/** ResponseCheckTx code */
|
|
code?: number | null;
|
|
|
|
/** ResponseCheckTx data */
|
|
data?: Uint8Array | null;
|
|
|
|
/** ResponseCheckTx log */
|
|
log?: string | null;
|
|
|
|
/** ResponseCheckTx info */
|
|
info?: string | null;
|
|
|
|
/** ResponseCheckTx gasWanted */
|
|
gasWanted?: number | Long | null;
|
|
|
|
/** ResponseCheckTx gasUsed */
|
|
gasUsed?: number | Long | null;
|
|
|
|
/** ResponseCheckTx events */
|
|
events?: tendermint.abci.types.IEvent[] | null;
|
|
|
|
/** ResponseCheckTx codespace */
|
|
codespace?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseCheckTx. */
|
|
class ResponseCheckTx implements IResponseCheckTx {
|
|
/**
|
|
* Constructs a new ResponseCheckTx.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseCheckTx);
|
|
|
|
/** ResponseCheckTx code. */
|
|
public code: number;
|
|
|
|
/** ResponseCheckTx data. */
|
|
public data: Uint8Array;
|
|
|
|
/** ResponseCheckTx log. */
|
|
public log: string;
|
|
|
|
/** ResponseCheckTx info. */
|
|
public info: string;
|
|
|
|
/** ResponseCheckTx gasWanted. */
|
|
public gasWanted: number | Long;
|
|
|
|
/** ResponseCheckTx gasUsed. */
|
|
public gasUsed: number | Long;
|
|
|
|
/** ResponseCheckTx events. */
|
|
public events: tendermint.abci.types.IEvent[];
|
|
|
|
/** ResponseCheckTx codespace. */
|
|
public codespace: string;
|
|
|
|
/**
|
|
* Creates a new ResponseCheckTx instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseCheckTx instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseCheckTx,
|
|
): tendermint.abci.types.ResponseCheckTx;
|
|
|
|
/**
|
|
* Encodes the specified ResponseCheckTx message. Does not implicitly {@link tendermint.abci.types.ResponseCheckTx.verify|verify} messages.
|
|
* @param m ResponseCheckTx message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseCheckTx,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseCheckTx message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseCheckTx
|
|
* @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,
|
|
): tendermint.abci.types.ResponseCheckTx;
|
|
}
|
|
|
|
/** Properties of a ResponseDeliverTx. */
|
|
interface IResponseDeliverTx {
|
|
/** ResponseDeliverTx code */
|
|
code?: number | null;
|
|
|
|
/** ResponseDeliverTx data */
|
|
data?: Uint8Array | null;
|
|
|
|
/** ResponseDeliverTx log */
|
|
log?: string | null;
|
|
|
|
/** ResponseDeliverTx info */
|
|
info?: string | null;
|
|
|
|
/** ResponseDeliverTx gasWanted */
|
|
gasWanted?: number | Long | null;
|
|
|
|
/** ResponseDeliverTx gasUsed */
|
|
gasUsed?: number | Long | null;
|
|
|
|
/** ResponseDeliverTx events */
|
|
events?: tendermint.abci.types.IEvent[] | null;
|
|
|
|
/** ResponseDeliverTx codespace */
|
|
codespace?: string | null;
|
|
}
|
|
|
|
/** Represents a ResponseDeliverTx. */
|
|
class ResponseDeliverTx implements IResponseDeliverTx {
|
|
/**
|
|
* Constructs a new ResponseDeliverTx.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseDeliverTx);
|
|
|
|
/** ResponseDeliverTx code. */
|
|
public code: number;
|
|
|
|
/** ResponseDeliverTx data. */
|
|
public data: Uint8Array;
|
|
|
|
/** ResponseDeliverTx log. */
|
|
public log: string;
|
|
|
|
/** ResponseDeliverTx info. */
|
|
public info: string;
|
|
|
|
/** ResponseDeliverTx gasWanted. */
|
|
public gasWanted: number | Long;
|
|
|
|
/** ResponseDeliverTx gasUsed. */
|
|
public gasUsed: number | Long;
|
|
|
|
/** ResponseDeliverTx events. */
|
|
public events: tendermint.abci.types.IEvent[];
|
|
|
|
/** ResponseDeliverTx codespace. */
|
|
public codespace: string;
|
|
|
|
/**
|
|
* Creates a new ResponseDeliverTx instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseDeliverTx instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseDeliverTx,
|
|
): tendermint.abci.types.ResponseDeliverTx;
|
|
|
|
/**
|
|
* Encodes the specified ResponseDeliverTx message. Does not implicitly {@link tendermint.abci.types.ResponseDeliverTx.verify|verify} messages.
|
|
* @param m ResponseDeliverTx message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseDeliverTx,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseDeliverTx message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseDeliverTx
|
|
* @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,
|
|
): tendermint.abci.types.ResponseDeliverTx;
|
|
}
|
|
|
|
/** Properties of a ResponseEndBlock. */
|
|
interface IResponseEndBlock {
|
|
/** ResponseEndBlock validatorUpdates */
|
|
validatorUpdates?: tendermint.abci.types.IValidatorUpdate[] | null;
|
|
|
|
/** ResponseEndBlock consensusParamUpdates */
|
|
consensusParamUpdates?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** ResponseEndBlock events */
|
|
events?: tendermint.abci.types.IEvent[] | null;
|
|
}
|
|
|
|
/** Represents a ResponseEndBlock. */
|
|
class ResponseEndBlock implements IResponseEndBlock {
|
|
/**
|
|
* Constructs a new ResponseEndBlock.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseEndBlock);
|
|
|
|
/** ResponseEndBlock validatorUpdates. */
|
|
public validatorUpdates: tendermint.abci.types.IValidatorUpdate[];
|
|
|
|
/** ResponseEndBlock consensusParamUpdates. */
|
|
public consensusParamUpdates?: tendermint.abci.types.IConsensusParams | null;
|
|
|
|
/** ResponseEndBlock events. */
|
|
public events: tendermint.abci.types.IEvent[];
|
|
|
|
/**
|
|
* Creates a new ResponseEndBlock instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseEndBlock instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseEndBlock,
|
|
): tendermint.abci.types.ResponseEndBlock;
|
|
|
|
/**
|
|
* Encodes the specified ResponseEndBlock message. Does not implicitly {@link tendermint.abci.types.ResponseEndBlock.verify|verify} messages.
|
|
* @param m ResponseEndBlock message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseEndBlock,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseEndBlock message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseEndBlock
|
|
* @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,
|
|
): tendermint.abci.types.ResponseEndBlock;
|
|
}
|
|
|
|
/** Properties of a ResponseCommit. */
|
|
interface IResponseCommit {
|
|
/** ResponseCommit data */
|
|
data?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a ResponseCommit. */
|
|
class ResponseCommit implements IResponseCommit {
|
|
/**
|
|
* Constructs a new ResponseCommit.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IResponseCommit);
|
|
|
|
/** ResponseCommit data. */
|
|
public data: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new ResponseCommit instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ResponseCommit instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IResponseCommit,
|
|
): tendermint.abci.types.ResponseCommit;
|
|
|
|
/**
|
|
* Encodes the specified ResponseCommit message. Does not implicitly {@link tendermint.abci.types.ResponseCommit.verify|verify} messages.
|
|
* @param m ResponseCommit message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IResponseCommit,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ResponseCommit message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ResponseCommit
|
|
* @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,
|
|
): tendermint.abci.types.ResponseCommit;
|
|
}
|
|
|
|
/** Properties of a ConsensusParams. */
|
|
interface IConsensusParams {
|
|
/** ConsensusParams block */
|
|
block?: tendermint.abci.types.IBlockParams | null;
|
|
|
|
/** ConsensusParams evidence */
|
|
evidence?: tendermint.abci.types.IEvidenceParams | null;
|
|
|
|
/** ConsensusParams validator */
|
|
validator?: tendermint.abci.types.IValidatorParams | null;
|
|
}
|
|
|
|
/** Represents a ConsensusParams. */
|
|
class ConsensusParams implements IConsensusParams {
|
|
/**
|
|
* Constructs a new ConsensusParams.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IConsensusParams);
|
|
|
|
/** ConsensusParams block. */
|
|
public block?: tendermint.abci.types.IBlockParams | null;
|
|
|
|
/** ConsensusParams evidence. */
|
|
public evidence?: tendermint.abci.types.IEvidenceParams | null;
|
|
|
|
/** ConsensusParams validator. */
|
|
public validator?: tendermint.abci.types.IValidatorParams | null;
|
|
|
|
/**
|
|
* Creates a new ConsensusParams instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ConsensusParams instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IConsensusParams,
|
|
): tendermint.abci.types.ConsensusParams;
|
|
|
|
/**
|
|
* Encodes the specified ConsensusParams message. Does not implicitly {@link tendermint.abci.types.ConsensusParams.verify|verify} messages.
|
|
* @param m ConsensusParams message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IConsensusParams,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ConsensusParams message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ConsensusParams
|
|
* @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,
|
|
): tendermint.abci.types.ConsensusParams;
|
|
}
|
|
|
|
/** Properties of a BlockParams. */
|
|
interface IBlockParams {
|
|
/** BlockParams maxBytes */
|
|
maxBytes?: number | Long | null;
|
|
|
|
/** BlockParams maxGas */
|
|
maxGas?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a BlockParams. */
|
|
class BlockParams implements IBlockParams {
|
|
/**
|
|
* Constructs a new BlockParams.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IBlockParams);
|
|
|
|
/** BlockParams maxBytes. */
|
|
public maxBytes: number | Long;
|
|
|
|
/** BlockParams maxGas. */
|
|
public maxGas: number | Long;
|
|
|
|
/**
|
|
* Creates a new BlockParams instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns BlockParams instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IBlockParams,
|
|
): tendermint.abci.types.BlockParams;
|
|
|
|
/**
|
|
* Encodes the specified BlockParams message. Does not implicitly {@link tendermint.abci.types.BlockParams.verify|verify} messages.
|
|
* @param m BlockParams message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IBlockParams, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a BlockParams message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns BlockParams
|
|
* @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): tendermint.abci.types.BlockParams;
|
|
}
|
|
|
|
/** Properties of an EvidenceParams. */
|
|
interface IEvidenceParams {
|
|
/** EvidenceParams maxAgeNumBlocks */
|
|
maxAgeNumBlocks?: number | Long | null;
|
|
|
|
/** EvidenceParams maxAgeDuration */
|
|
maxAgeDuration?: google.protobuf.IDuration | null;
|
|
}
|
|
|
|
/** Represents an EvidenceParams. */
|
|
class EvidenceParams implements IEvidenceParams {
|
|
/**
|
|
* Constructs a new EvidenceParams.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IEvidenceParams);
|
|
|
|
/** EvidenceParams maxAgeNumBlocks. */
|
|
public maxAgeNumBlocks: number | Long;
|
|
|
|
/** EvidenceParams maxAgeDuration. */
|
|
public maxAgeDuration?: google.protobuf.IDuration | null;
|
|
|
|
/**
|
|
* Creates a new EvidenceParams instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns EvidenceParams instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IEvidenceParams,
|
|
): tendermint.abci.types.EvidenceParams;
|
|
|
|
/**
|
|
* Encodes the specified EvidenceParams message. Does not implicitly {@link tendermint.abci.types.EvidenceParams.verify|verify} messages.
|
|
* @param m EvidenceParams message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IEvidenceParams,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an EvidenceParams message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns EvidenceParams
|
|
* @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,
|
|
): tendermint.abci.types.EvidenceParams;
|
|
}
|
|
|
|
/** Properties of a ValidatorParams. */
|
|
interface IValidatorParams {
|
|
/** ValidatorParams pubKeyTypes */
|
|
pubKeyTypes?: string[] | null;
|
|
}
|
|
|
|
/** Represents a ValidatorParams. */
|
|
class ValidatorParams implements IValidatorParams {
|
|
/**
|
|
* Constructs a new ValidatorParams.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IValidatorParams);
|
|
|
|
/** ValidatorParams pubKeyTypes. */
|
|
public pubKeyTypes: string[];
|
|
|
|
/**
|
|
* Creates a new ValidatorParams instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ValidatorParams instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IValidatorParams,
|
|
): tendermint.abci.types.ValidatorParams;
|
|
|
|
/**
|
|
* Encodes the specified ValidatorParams message. Does not implicitly {@link tendermint.abci.types.ValidatorParams.verify|verify} messages.
|
|
* @param m ValidatorParams message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IValidatorParams,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ValidatorParams message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ValidatorParams
|
|
* @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,
|
|
): tendermint.abci.types.ValidatorParams;
|
|
}
|
|
|
|
/** Properties of a LastCommitInfo. */
|
|
interface ILastCommitInfo {
|
|
/** LastCommitInfo round */
|
|
round?: number | null;
|
|
|
|
/** LastCommitInfo votes */
|
|
votes?: tendermint.abci.types.IVoteInfo[] | null;
|
|
}
|
|
|
|
/** Represents a LastCommitInfo. */
|
|
class LastCommitInfo implements ILastCommitInfo {
|
|
/**
|
|
* Constructs a new LastCommitInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.ILastCommitInfo);
|
|
|
|
/** LastCommitInfo round. */
|
|
public round: number;
|
|
|
|
/** LastCommitInfo votes. */
|
|
public votes: tendermint.abci.types.IVoteInfo[];
|
|
|
|
/**
|
|
* Creates a new LastCommitInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns LastCommitInfo instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.ILastCommitInfo,
|
|
): tendermint.abci.types.LastCommitInfo;
|
|
|
|
/**
|
|
* Encodes the specified LastCommitInfo message. Does not implicitly {@link tendermint.abci.types.LastCommitInfo.verify|verify} messages.
|
|
* @param m LastCommitInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.ILastCommitInfo,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a LastCommitInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns LastCommitInfo
|
|
* @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,
|
|
): tendermint.abci.types.LastCommitInfo;
|
|
}
|
|
|
|
/** Properties of an Event. */
|
|
interface IEvent {
|
|
/** Event type */
|
|
type?: string | null;
|
|
|
|
/** Event attributes */
|
|
attributes?: tendermint.libs.kv.IPair[] | null;
|
|
}
|
|
|
|
/** Represents an Event. */
|
|
class Event implements IEvent {
|
|
/**
|
|
* Constructs a new Event.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IEvent);
|
|
|
|
/** Event type. */
|
|
public type: string;
|
|
|
|
/** Event attributes. */
|
|
public attributes: tendermint.libs.kv.IPair[];
|
|
|
|
/**
|
|
* Creates a new Event instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Event instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IEvent): tendermint.abci.types.Event;
|
|
|
|
/**
|
|
* Encodes the specified Event message. Does not implicitly {@link tendermint.abci.types.Event.verify|verify} messages.
|
|
* @param m Event message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IEvent, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an Event message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Event
|
|
* @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): tendermint.abci.types.Event;
|
|
}
|
|
|
|
/** Properties of a Header. */
|
|
interface IHeader {
|
|
/** Header version */
|
|
version?: tendermint.abci.types.IVersion | null;
|
|
|
|
/** Header chainId */
|
|
chainId?: string | null;
|
|
|
|
/** Header height */
|
|
height?: number | Long | null;
|
|
|
|
/** Header time */
|
|
time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** Header lastBlockId */
|
|
lastBlockId?: tendermint.abci.types.IBlockID | null;
|
|
|
|
/** Header lastCommitHash */
|
|
lastCommitHash?: Uint8Array | null;
|
|
|
|
/** Header dataHash */
|
|
dataHash?: Uint8Array | null;
|
|
|
|
/** Header validatorsHash */
|
|
validatorsHash?: Uint8Array | null;
|
|
|
|
/** Header nextValidatorsHash */
|
|
nextValidatorsHash?: Uint8Array | null;
|
|
|
|
/** Header consensusHash */
|
|
consensusHash?: Uint8Array | null;
|
|
|
|
/** Header appHash */
|
|
appHash?: Uint8Array | null;
|
|
|
|
/** Header lastResultsHash */
|
|
lastResultsHash?: Uint8Array | null;
|
|
|
|
/** Header evidenceHash */
|
|
evidenceHash?: Uint8Array | null;
|
|
|
|
/** Header proposerAddress */
|
|
proposerAddress?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a Header. */
|
|
class Header implements IHeader {
|
|
/**
|
|
* Constructs a new Header.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IHeader);
|
|
|
|
/** Header version. */
|
|
public version?: tendermint.abci.types.IVersion | null;
|
|
|
|
/** Header chainId. */
|
|
public chainId: string;
|
|
|
|
/** Header height. */
|
|
public height: number | Long;
|
|
|
|
/** Header time. */
|
|
public time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** Header lastBlockId. */
|
|
public lastBlockId?: tendermint.abci.types.IBlockID | null;
|
|
|
|
/** Header lastCommitHash. */
|
|
public lastCommitHash: Uint8Array;
|
|
|
|
/** Header dataHash. */
|
|
public dataHash: Uint8Array;
|
|
|
|
/** Header validatorsHash. */
|
|
public validatorsHash: Uint8Array;
|
|
|
|
/** Header nextValidatorsHash. */
|
|
public nextValidatorsHash: Uint8Array;
|
|
|
|
/** Header consensusHash. */
|
|
public consensusHash: Uint8Array;
|
|
|
|
/** Header appHash. */
|
|
public appHash: Uint8Array;
|
|
|
|
/** Header lastResultsHash. */
|
|
public lastResultsHash: Uint8Array;
|
|
|
|
/** Header evidenceHash. */
|
|
public evidenceHash: Uint8Array;
|
|
|
|
/** Header proposerAddress. */
|
|
public proposerAddress: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new Header instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Header instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IHeader): tendermint.abci.types.Header;
|
|
|
|
/**
|
|
* Encodes the specified Header message. Does not implicitly {@link tendermint.abci.types.Header.verify|verify} messages.
|
|
* @param m Header message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IHeader, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Header message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Header
|
|
* @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): tendermint.abci.types.Header;
|
|
}
|
|
|
|
/** Properties of a Version. */
|
|
interface IVersion {
|
|
/** Version Block */
|
|
Block?: number | Long | null;
|
|
|
|
/** Version App */
|
|
App?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a Version. */
|
|
class Version implements IVersion {
|
|
/**
|
|
* Constructs a new Version.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IVersion);
|
|
|
|
/** Version Block. */
|
|
public Block: number | Long;
|
|
|
|
/** Version App. */
|
|
public App: number | Long;
|
|
|
|
/**
|
|
* Creates a new Version instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Version instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IVersion): tendermint.abci.types.Version;
|
|
|
|
/**
|
|
* Encodes the specified Version message. Does not implicitly {@link tendermint.abci.types.Version.verify|verify} messages.
|
|
* @param m Version message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IVersion, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Version message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Version
|
|
* @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): tendermint.abci.types.Version;
|
|
}
|
|
|
|
/** Properties of a BlockID. */
|
|
interface IBlockID {
|
|
/** BlockID hash */
|
|
hash?: Uint8Array | null;
|
|
|
|
/** BlockID partsHeader */
|
|
partsHeader?: tendermint.abci.types.IPartSetHeader | null;
|
|
}
|
|
|
|
/** Represents a BlockID. */
|
|
class BlockID implements IBlockID {
|
|
/**
|
|
* Constructs a new BlockID.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IBlockID);
|
|
|
|
/** BlockID hash. */
|
|
public hash: Uint8Array;
|
|
|
|
/** BlockID partsHeader. */
|
|
public partsHeader?: tendermint.abci.types.IPartSetHeader | null;
|
|
|
|
/**
|
|
* Creates a new BlockID instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns BlockID instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IBlockID): tendermint.abci.types.BlockID;
|
|
|
|
/**
|
|
* Encodes the specified BlockID message. Does not implicitly {@link tendermint.abci.types.BlockID.verify|verify} messages.
|
|
* @param m BlockID message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IBlockID, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a BlockID message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns BlockID
|
|
* @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): tendermint.abci.types.BlockID;
|
|
}
|
|
|
|
/** Properties of a PartSetHeader. */
|
|
interface IPartSetHeader {
|
|
/** PartSetHeader total */
|
|
total?: number | null;
|
|
|
|
/** PartSetHeader hash */
|
|
hash?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a PartSetHeader. */
|
|
class PartSetHeader implements IPartSetHeader {
|
|
/**
|
|
* Constructs a new PartSetHeader.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IPartSetHeader);
|
|
|
|
/** PartSetHeader total. */
|
|
public total: number;
|
|
|
|
/** PartSetHeader hash. */
|
|
public hash: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new PartSetHeader instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns PartSetHeader instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IPartSetHeader,
|
|
): tendermint.abci.types.PartSetHeader;
|
|
|
|
/**
|
|
* Encodes the specified PartSetHeader message. Does not implicitly {@link tendermint.abci.types.PartSetHeader.verify|verify} messages.
|
|
* @param m PartSetHeader message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IPartSetHeader, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a PartSetHeader message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns PartSetHeader
|
|
* @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,
|
|
): tendermint.abci.types.PartSetHeader;
|
|
}
|
|
|
|
/** Properties of a Validator. */
|
|
interface IValidator {
|
|
/** Validator address */
|
|
address?: Uint8Array | null;
|
|
|
|
/** Validator power */
|
|
power?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a Validator. */
|
|
class Validator implements IValidator {
|
|
/**
|
|
* Constructs a new Validator.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IValidator);
|
|
|
|
/** Validator address. */
|
|
public address: Uint8Array;
|
|
|
|
/** Validator power. */
|
|
public power: number | Long;
|
|
|
|
/**
|
|
* Creates a new Validator instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Validator instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IValidator): tendermint.abci.types.Validator;
|
|
|
|
/**
|
|
* Encodes the specified Validator message. Does not implicitly {@link tendermint.abci.types.Validator.verify|verify} messages.
|
|
* @param m Validator message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IValidator, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Validator message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Validator
|
|
* @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): tendermint.abci.types.Validator;
|
|
}
|
|
|
|
/** Properties of a ValidatorUpdate. */
|
|
interface IValidatorUpdate {
|
|
/** ValidatorUpdate pubKey */
|
|
pubKey?: tendermint.abci.types.IPubKey | null;
|
|
|
|
/** ValidatorUpdate power */
|
|
power?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a ValidatorUpdate. */
|
|
class ValidatorUpdate implements IValidatorUpdate {
|
|
/**
|
|
* Constructs a new ValidatorUpdate.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IValidatorUpdate);
|
|
|
|
/** ValidatorUpdate pubKey. */
|
|
public pubKey?: tendermint.abci.types.IPubKey | null;
|
|
|
|
/** ValidatorUpdate power. */
|
|
public power: number | Long;
|
|
|
|
/**
|
|
* Creates a new ValidatorUpdate instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ValidatorUpdate instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.abci.types.IValidatorUpdate,
|
|
): tendermint.abci.types.ValidatorUpdate;
|
|
|
|
/**
|
|
* Encodes the specified ValidatorUpdate message. Does not implicitly {@link tendermint.abci.types.ValidatorUpdate.verify|verify} messages.
|
|
* @param m ValidatorUpdate message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(
|
|
m: tendermint.abci.types.IValidatorUpdate,
|
|
w?: $protobuf.Writer,
|
|
): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ValidatorUpdate message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ValidatorUpdate
|
|
* @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,
|
|
): tendermint.abci.types.ValidatorUpdate;
|
|
}
|
|
|
|
/** Properties of a VoteInfo. */
|
|
interface IVoteInfo {
|
|
/** VoteInfo validator */
|
|
validator?: tendermint.abci.types.IValidator | null;
|
|
|
|
/** VoteInfo signedLastBlock */
|
|
signedLastBlock?: boolean | null;
|
|
}
|
|
|
|
/** Represents a VoteInfo. */
|
|
class VoteInfo implements IVoteInfo {
|
|
/**
|
|
* Constructs a new VoteInfo.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IVoteInfo);
|
|
|
|
/** VoteInfo validator. */
|
|
public validator?: tendermint.abci.types.IValidator | null;
|
|
|
|
/** VoteInfo signedLastBlock. */
|
|
public signedLastBlock: boolean;
|
|
|
|
/**
|
|
* Creates a new VoteInfo instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns VoteInfo instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IVoteInfo): tendermint.abci.types.VoteInfo;
|
|
|
|
/**
|
|
* Encodes the specified VoteInfo message. Does not implicitly {@link tendermint.abci.types.VoteInfo.verify|verify} messages.
|
|
* @param m VoteInfo message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IVoteInfo, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a VoteInfo message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns VoteInfo
|
|
* @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): tendermint.abci.types.VoteInfo;
|
|
}
|
|
|
|
/** Properties of a PubKey. */
|
|
interface IPubKey {
|
|
/** PubKey type */
|
|
type?: string | null;
|
|
|
|
/** PubKey data */
|
|
data?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a PubKey. */
|
|
class PubKey implements IPubKey {
|
|
/**
|
|
* Constructs a new PubKey.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IPubKey);
|
|
|
|
/** PubKey type. */
|
|
public type: string;
|
|
|
|
/** PubKey data. */
|
|
public data: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new PubKey instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns PubKey instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IPubKey): tendermint.abci.types.PubKey;
|
|
|
|
/**
|
|
* Encodes the specified PubKey message. Does not implicitly {@link tendermint.abci.types.PubKey.verify|verify} messages.
|
|
* @param m PubKey message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IPubKey, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a PubKey message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns PubKey
|
|
* @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): tendermint.abci.types.PubKey;
|
|
}
|
|
|
|
/** Properties of an Evidence. */
|
|
interface IEvidence {
|
|
/** Evidence type */
|
|
type?: string | null;
|
|
|
|
/** Evidence validator */
|
|
validator?: tendermint.abci.types.IValidator | null;
|
|
|
|
/** Evidence height */
|
|
height?: number | Long | null;
|
|
|
|
/** Evidence time */
|
|
time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** Evidence totalVotingPower */
|
|
totalVotingPower?: number | Long | null;
|
|
}
|
|
|
|
/** Represents an Evidence. */
|
|
class Evidence implements IEvidence {
|
|
/**
|
|
* Constructs a new Evidence.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.abci.types.IEvidence);
|
|
|
|
/** Evidence type. */
|
|
public type: string;
|
|
|
|
/** Evidence validator. */
|
|
public validator?: tendermint.abci.types.IValidator | null;
|
|
|
|
/** Evidence height. */
|
|
public height: number | Long;
|
|
|
|
/** Evidence time. */
|
|
public time?: google.protobuf.ITimestamp | null;
|
|
|
|
/** Evidence totalVotingPower. */
|
|
public totalVotingPower: number | Long;
|
|
|
|
/**
|
|
* Creates a new Evidence instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Evidence instance
|
|
*/
|
|
public static create(properties?: tendermint.abci.types.IEvidence): tendermint.abci.types.Evidence;
|
|
|
|
/**
|
|
* Encodes the specified Evidence message. Does not implicitly {@link tendermint.abci.types.Evidence.verify|verify} messages.
|
|
* @param m Evidence message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.abci.types.IEvidence, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an Evidence message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Evidence
|
|
* @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): tendermint.abci.types.Evidence;
|
|
}
|
|
|
|
/** Represents a ABCIApplication */
|
|
class ABCIApplication extends $protobuf.rpc.Service {
|
|
/**
|
|
* Constructs a new ABCIApplication service.
|
|
* @param rpcImpl RPC implementation
|
|
* @param [requestDelimited=false] Whether requests are length-delimited
|
|
* @param [responseDelimited=false] Whether responses are length-delimited
|
|
*/
|
|
constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean);
|
|
|
|
/**
|
|
* Creates new ABCIApplication service using the specified rpc implementation.
|
|
* @param rpcImpl RPC implementation
|
|
* @param [requestDelimited=false] Whether requests are length-delimited
|
|
* @param [responseDelimited=false] Whether responses are length-delimited
|
|
* @returns RPC service. Useful where requests and/or responses are streamed.
|
|
*/
|
|
public static create(
|
|
rpcImpl: $protobuf.RPCImpl,
|
|
requestDelimited?: boolean,
|
|
responseDelimited?: boolean,
|
|
): ABCIApplication;
|
|
|
|
/**
|
|
* Calls Echo.
|
|
* @param request RequestEcho message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseEcho
|
|
*/
|
|
public echo(
|
|
request: tendermint.abci.types.IRequestEcho,
|
|
callback: tendermint.abci.types.ABCIApplication.EchoCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls Echo.
|
|
* @param request RequestEcho message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public echo(request: tendermint.abci.types.IRequestEcho): Promise<tendermint.abci.types.ResponseEcho>;
|
|
|
|
/**
|
|
* Calls Flush.
|
|
* @param request RequestFlush message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseFlush
|
|
*/
|
|
public flush(
|
|
request: tendermint.abci.types.IRequestFlush,
|
|
callback: tendermint.abci.types.ABCIApplication.FlushCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls Flush.
|
|
* @param request RequestFlush message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public flush(
|
|
request: tendermint.abci.types.IRequestFlush,
|
|
): Promise<tendermint.abci.types.ResponseFlush>;
|
|
|
|
/**
|
|
* Calls Info.
|
|
* @param request RequestInfo message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseInfo
|
|
*/
|
|
public info(
|
|
request: tendermint.abci.types.IRequestInfo,
|
|
callback: tendermint.abci.types.ABCIApplication.InfoCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls Info.
|
|
* @param request RequestInfo message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public info(request: tendermint.abci.types.IRequestInfo): Promise<tendermint.abci.types.ResponseInfo>;
|
|
|
|
/**
|
|
* Calls SetOption.
|
|
* @param request RequestSetOption message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseSetOption
|
|
*/
|
|
public setOption(
|
|
request: tendermint.abci.types.IRequestSetOption,
|
|
callback: tendermint.abci.types.ABCIApplication.SetOptionCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls SetOption.
|
|
* @param request RequestSetOption message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public setOption(
|
|
request: tendermint.abci.types.IRequestSetOption,
|
|
): Promise<tendermint.abci.types.ResponseSetOption>;
|
|
|
|
/**
|
|
* Calls DeliverTx.
|
|
* @param request RequestDeliverTx message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseDeliverTx
|
|
*/
|
|
public deliverTx(
|
|
request: tendermint.abci.types.IRequestDeliverTx,
|
|
callback: tendermint.abci.types.ABCIApplication.DeliverTxCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls DeliverTx.
|
|
* @param request RequestDeliverTx message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public deliverTx(
|
|
request: tendermint.abci.types.IRequestDeliverTx,
|
|
): Promise<tendermint.abci.types.ResponseDeliverTx>;
|
|
|
|
/**
|
|
* Calls CheckTx.
|
|
* @param request RequestCheckTx message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseCheckTx
|
|
*/
|
|
public checkTx(
|
|
request: tendermint.abci.types.IRequestCheckTx,
|
|
callback: tendermint.abci.types.ABCIApplication.CheckTxCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls CheckTx.
|
|
* @param request RequestCheckTx message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public checkTx(
|
|
request: tendermint.abci.types.IRequestCheckTx,
|
|
): Promise<tendermint.abci.types.ResponseCheckTx>;
|
|
|
|
/**
|
|
* Calls Query.
|
|
* @param request RequestQuery message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseQuery
|
|
*/
|
|
public query(
|
|
request: tendermint.abci.types.IRequestQuery,
|
|
callback: tendermint.abci.types.ABCIApplication.QueryCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls Query.
|
|
* @param request RequestQuery message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public query(
|
|
request: tendermint.abci.types.IRequestQuery,
|
|
): Promise<tendermint.abci.types.ResponseQuery>;
|
|
|
|
/**
|
|
* Calls Commit.
|
|
* @param request RequestCommit message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseCommit
|
|
*/
|
|
public commit(
|
|
request: tendermint.abci.types.IRequestCommit,
|
|
callback: tendermint.abci.types.ABCIApplication.CommitCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls Commit.
|
|
* @param request RequestCommit message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public commit(
|
|
request: tendermint.abci.types.IRequestCommit,
|
|
): Promise<tendermint.abci.types.ResponseCommit>;
|
|
|
|
/**
|
|
* Calls InitChain.
|
|
* @param request RequestInitChain message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseInitChain
|
|
*/
|
|
public initChain(
|
|
request: tendermint.abci.types.IRequestInitChain,
|
|
callback: tendermint.abci.types.ABCIApplication.InitChainCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls InitChain.
|
|
* @param request RequestInitChain message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public initChain(
|
|
request: tendermint.abci.types.IRequestInitChain,
|
|
): Promise<tendermint.abci.types.ResponseInitChain>;
|
|
|
|
/**
|
|
* Calls BeginBlock.
|
|
* @param request RequestBeginBlock message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseBeginBlock
|
|
*/
|
|
public beginBlock(
|
|
request: tendermint.abci.types.IRequestBeginBlock,
|
|
callback: tendermint.abci.types.ABCIApplication.BeginBlockCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls BeginBlock.
|
|
* @param request RequestBeginBlock message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public beginBlock(
|
|
request: tendermint.abci.types.IRequestBeginBlock,
|
|
): Promise<tendermint.abci.types.ResponseBeginBlock>;
|
|
|
|
/**
|
|
* Calls EndBlock.
|
|
* @param request RequestEndBlock message or plain object
|
|
* @param callback Node-style callback called with the error, if any, and ResponseEndBlock
|
|
*/
|
|
public endBlock(
|
|
request: tendermint.abci.types.IRequestEndBlock,
|
|
callback: tendermint.abci.types.ABCIApplication.EndBlockCallback,
|
|
): void;
|
|
|
|
/**
|
|
* Calls EndBlock.
|
|
* @param request RequestEndBlock message or plain object
|
|
* @returns Promise
|
|
*/
|
|
public endBlock(
|
|
request: tendermint.abci.types.IRequestEndBlock,
|
|
): Promise<tendermint.abci.types.ResponseEndBlock>;
|
|
}
|
|
|
|
namespace ABCIApplication {
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#echo}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseEcho
|
|
*/
|
|
type EchoCallback = (error: Error | null, response?: tendermint.abci.types.ResponseEcho) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#flush}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseFlush
|
|
*/
|
|
type FlushCallback = (error: Error | null, response?: tendermint.abci.types.ResponseFlush) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#info}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseInfo
|
|
*/
|
|
type InfoCallback = (error: Error | null, response?: tendermint.abci.types.ResponseInfo) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#setOption}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseSetOption
|
|
*/
|
|
type SetOptionCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseSetOption,
|
|
) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#deliverTx}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseDeliverTx
|
|
*/
|
|
type DeliverTxCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseDeliverTx,
|
|
) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#checkTx}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseCheckTx
|
|
*/
|
|
type CheckTxCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseCheckTx,
|
|
) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#query}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseQuery
|
|
*/
|
|
type QueryCallback = (error: Error | null, response?: tendermint.abci.types.ResponseQuery) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#commit}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseCommit
|
|
*/
|
|
type CommitCallback = (error: Error | null, response?: tendermint.abci.types.ResponseCommit) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#initChain}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseInitChain
|
|
*/
|
|
type InitChainCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseInitChain,
|
|
) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#beginBlock}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseBeginBlock
|
|
*/
|
|
type BeginBlockCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseBeginBlock,
|
|
) => void;
|
|
|
|
/**
|
|
* Callback as used by {@link tendermint.abci.types.ABCIApplication#endBlock}.
|
|
* @param error Error, if any
|
|
* @param [response] ResponseEndBlock
|
|
*/
|
|
type EndBlockCallback = (
|
|
error: Error | null,
|
|
response?: tendermint.abci.types.ResponseEndBlock,
|
|
) => void;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace crypto. */
|
|
namespace crypto {
|
|
/** Namespace merkle. */
|
|
namespace merkle {
|
|
/** Properties of a ProofOp. */
|
|
interface IProofOp {
|
|
/** ProofOp type */
|
|
type?: string | null;
|
|
|
|
/** ProofOp key */
|
|
key?: Uint8Array | null;
|
|
|
|
/** ProofOp data */
|
|
data?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a ProofOp. */
|
|
class ProofOp implements IProofOp {
|
|
/**
|
|
* Constructs a new ProofOp.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.crypto.merkle.IProofOp);
|
|
|
|
/** ProofOp type. */
|
|
public type: string;
|
|
|
|
/** ProofOp key. */
|
|
public key: Uint8Array;
|
|
|
|
/** ProofOp data. */
|
|
public data: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new ProofOp instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns ProofOp instance
|
|
*/
|
|
public static create(
|
|
properties?: tendermint.crypto.merkle.IProofOp,
|
|
): tendermint.crypto.merkle.ProofOp;
|
|
|
|
/**
|
|
* Encodes the specified ProofOp message. Does not implicitly {@link tendermint.crypto.merkle.ProofOp.verify|verify} messages.
|
|
* @param m ProofOp message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.crypto.merkle.IProofOp, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a ProofOp message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns ProofOp
|
|
* @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): tendermint.crypto.merkle.ProofOp;
|
|
}
|
|
|
|
/** Properties of a Proof. */
|
|
interface IProof {
|
|
/** Proof ops */
|
|
ops?: tendermint.crypto.merkle.IProofOp[] | null;
|
|
}
|
|
|
|
/** Represents a Proof. */
|
|
class Proof implements IProof {
|
|
/**
|
|
* Constructs a new Proof.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.crypto.merkle.IProof);
|
|
|
|
/** Proof ops. */
|
|
public ops: tendermint.crypto.merkle.IProofOp[];
|
|
|
|
/**
|
|
* Creates a new Proof instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Proof instance
|
|
*/
|
|
public static create(properties?: tendermint.crypto.merkle.IProof): tendermint.crypto.merkle.Proof;
|
|
|
|
/**
|
|
* Encodes the specified Proof message. Does not implicitly {@link tendermint.crypto.merkle.Proof.verify|verify} messages.
|
|
* @param m Proof message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.crypto.merkle.IProof, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Proof message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Proof
|
|
* @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): tendermint.crypto.merkle.Proof;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace libs. */
|
|
namespace libs {
|
|
/** Namespace kv. */
|
|
namespace kv {
|
|
/** Properties of a Pair. */
|
|
interface IPair {
|
|
/** Pair key */
|
|
key?: Uint8Array | null;
|
|
|
|
/** Pair value */
|
|
value?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents a Pair. */
|
|
class Pair implements IPair {
|
|
/**
|
|
* Constructs a new Pair.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.libs.kv.IPair);
|
|
|
|
/** Pair key. */
|
|
public key: Uint8Array;
|
|
|
|
/** Pair value. */
|
|
public value: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new Pair instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Pair instance
|
|
*/
|
|
public static create(properties?: tendermint.libs.kv.IPair): tendermint.libs.kv.Pair;
|
|
|
|
/**
|
|
* Encodes the specified Pair message. Does not implicitly {@link tendermint.libs.kv.Pair.verify|verify} messages.
|
|
* @param m Pair message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.libs.kv.IPair, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Pair message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Pair
|
|
* @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): tendermint.libs.kv.Pair;
|
|
}
|
|
|
|
/** Properties of a KI64Pair. */
|
|
interface IKI64Pair {
|
|
/** KI64Pair key */
|
|
key?: Uint8Array | null;
|
|
|
|
/** KI64Pair value */
|
|
value?: number | Long | null;
|
|
}
|
|
|
|
/** Represents a KI64Pair. */
|
|
class KI64Pair implements IKI64Pair {
|
|
/**
|
|
* Constructs a new KI64Pair.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: tendermint.libs.kv.IKI64Pair);
|
|
|
|
/** KI64Pair key. */
|
|
public key: Uint8Array;
|
|
|
|
/** KI64Pair value. */
|
|
public value: number | Long;
|
|
|
|
/**
|
|
* Creates a new KI64Pair instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns KI64Pair instance
|
|
*/
|
|
public static create(properties?: tendermint.libs.kv.IKI64Pair): tendermint.libs.kv.KI64Pair;
|
|
|
|
/**
|
|
* Encodes the specified KI64Pair message. Does not implicitly {@link tendermint.libs.kv.KI64Pair.verify|verify} messages.
|
|
* @param m KI64Pair message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: tendermint.libs.kv.IKI64Pair, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a KI64Pair message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns KI64Pair
|
|
* @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): tendermint.libs.kv.KI64Pair;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Namespace google. */
|
|
export namespace google {
|
|
/** Namespace protobuf. */
|
|
namespace protobuf {
|
|
/** Properties of an Any. */
|
|
interface IAny {
|
|
/** Any type_url */
|
|
type_url?: string | null;
|
|
|
|
/** Any value */
|
|
value?: Uint8Array | null;
|
|
}
|
|
|
|
/** Represents an Any. */
|
|
class Any implements IAny {
|
|
/**
|
|
* Constructs a new Any.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: google.protobuf.IAny);
|
|
|
|
/** Any type_url. */
|
|
public type_url: string;
|
|
|
|
/** Any value. */
|
|
public value: Uint8Array;
|
|
|
|
/**
|
|
* Creates a new Any instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Any instance
|
|
*/
|
|
public static create(properties?: google.protobuf.IAny): google.protobuf.Any;
|
|
|
|
/**
|
|
* Encodes the specified Any message. Does not implicitly {@link google.protobuf.Any.verify|verify} messages.
|
|
* @param m Any message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: google.protobuf.IAny, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes an Any message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Any
|
|
* @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): google.protobuf.Any;
|
|
}
|
|
|
|
/** Properties of a Timestamp. */
|
|
interface ITimestamp {
|
|
/** Timestamp seconds */
|
|
seconds?: number | Long | null;
|
|
|
|
/** Timestamp nanos */
|
|
nanos?: number | null;
|
|
}
|
|
|
|
/** Represents a Timestamp. */
|
|
class Timestamp implements ITimestamp {
|
|
/**
|
|
* Constructs a new Timestamp.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: google.protobuf.ITimestamp);
|
|
|
|
/** Timestamp seconds. */
|
|
public seconds: number | Long;
|
|
|
|
/** Timestamp nanos. */
|
|
public nanos: number;
|
|
|
|
/**
|
|
* Creates a new Timestamp instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Timestamp instance
|
|
*/
|
|
public static create(properties?: google.protobuf.ITimestamp): google.protobuf.Timestamp;
|
|
|
|
/**
|
|
* Encodes the specified Timestamp message. Does not implicitly {@link google.protobuf.Timestamp.verify|verify} messages.
|
|
* @param m Timestamp message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: google.protobuf.ITimestamp, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Timestamp message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Timestamp
|
|
* @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): google.protobuf.Timestamp;
|
|
}
|
|
|
|
/** Properties of a Duration. */
|
|
interface IDuration {
|
|
/** Duration seconds */
|
|
seconds?: number | Long | null;
|
|
|
|
/** Duration nanos */
|
|
nanos?: number | null;
|
|
}
|
|
|
|
/** Represents a Duration. */
|
|
class Duration implements IDuration {
|
|
/**
|
|
* Constructs a new Duration.
|
|
* @param [p] Properties to set
|
|
*/
|
|
constructor(p?: google.protobuf.IDuration);
|
|
|
|
/** Duration seconds. */
|
|
public seconds: number | Long;
|
|
|
|
/** Duration nanos. */
|
|
public nanos: number;
|
|
|
|
/**
|
|
* Creates a new Duration instance using the specified properties.
|
|
* @param [properties] Properties to set
|
|
* @returns Duration instance
|
|
*/
|
|
public static create(properties?: google.protobuf.IDuration): google.protobuf.Duration;
|
|
|
|
/**
|
|
* Encodes the specified Duration message. Does not implicitly {@link google.protobuf.Duration.verify|verify} messages.
|
|
* @param m Duration message or plain object to encode
|
|
* @param [w] Writer to encode to
|
|
* @returns Writer
|
|
*/
|
|
public static encode(m: google.protobuf.IDuration, w?: $protobuf.Writer): $protobuf.Writer;
|
|
|
|
/**
|
|
* Decodes a Duration message from the specified reader or buffer.
|
|
* @param r Reader or buffer to decode from
|
|
* @param [l] Message length if known beforehand
|
|
* @returns Duration
|
|
* @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): google.protobuf.Duration;
|
|
}
|
|
}
|
|
}
|